regions-0.4/0000755000076600000240000000000013501657425013074 5ustar deilstaff00000000000000regions-0.4/CHANGES.rst0000644000076600000240000000617013501657346014704 0ustar deilstaff000000000000000.4 (2019-06-17) ================ New Features ------------ - Add region copy methods [#269] - Add pixel region rotate method [#265] - Added ``union`` and ``intersection`` methods to the ``BoundingBox`` class. [#277] - Add support for BOX in FITS regions [#255] - Add PixCoord.xy [#247] Bug Fixes --------- - Fixed a corner-case issue where ``RegionMask.multiply()`` would not set non-finite data values outside of the mask but within the bounding box to zero. [#278] - Fix 'text' renamed to 'label' [#234] Other ----- - Remove astropy-healpix dependency [#258] - Use standalone six to avoid deprecation warnings [#235] - Change CRTF writer to match CASA implementation [#226] - Simplify annulus regions [#279] See also: `regions v0.4 merged pull requests list on Github `__. 0.3 (2018-09-09) ================ New features ------------ - Changed ``as_patch`` to ``as_artist`` to accommodate non-patch artists [#218] - Implemented ``to_pixel`` for ``regions.CompoundSkyRegions``, ``to_mask`` for ``regions.CompoundPixelRegion`` and ``to_pixel`` for ``regions.CircleSkyRegion``. [#137] - Handling dimension and broadcast of `x` and `y` in ``regions.PixCoord``. [#172] - Deserialization of ``CRTF`` file format is possible. [#173] - Added ``regions.TextPixelRegion`` and ``regions.TextSkyRegion``. [#177] - Added ``Shape`` layer in the serialization of ``DS9`` format. Also, implemented ``RegionMeta`` and ``RegionVisual`` to validate the meta parameters. [#179] - Serialization of ``regions.Region`` object to ``CRTF`` format is possible. [#186] - Fix mask bug for regions with negative indices. [#190] - Improved the ``plot`` methods for several regions. Added ``as_patch`` for annulus regions. Now, uses the parameters in the ``visual`` attributes of regions in the matplotlib plotting. Also, added ``mpl_properties_default`` method in ``regions.PixelRegion`` to set the visual parameters to that of ``DS9`` by default. [#194] - Now, ``to_mask`` in ``regions.CompoundPixelRegion`` handles negative bounding box. [#195] - Added ``regions.RectangleAnnulusPixelRegion``, ``regions.RectangleAnnulusSkyRegion``, ``regions.EllipseAnnulusPixelRegion`` and ``regions.RectangleAnnulusSkyRegion``. Also, implemented custom descriptor classes for attribute validation. [#196] - Implemented FITS Region Binary Table reader and writer. [#198] - Renamed ``Mask`` class to ``RegionMask`` and added ``origin`` arg to ``as_patch`` and ``plot`` methods in ``regions.Region`` class. [#203] - Support for explicit formatting directives in ``DS9``. [#204] See also: `regions v0.3 merged pull requests list on Github `__. 0.2 (2017-02-16) ================ Changelog wasn't filled. See also: `regions v0.2 merged pull requests list on Github `__. 0.1 (2016-07-26) ================ Changelog wasn't filled. See also: `regions v0.1 merged pull requests list on Github `__. regions-0.4/LICENSE.rst0000644000076600000240000000273213336761120014706 0ustar deilstaff00000000000000Copyright (c) 2015-2017, Regions developers All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the developer team nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. regions-0.4/PKG-INFO0000644000076600000240000000135113501657425014171 0ustar deilstaff00000000000000Metadata-Version: 2.1 Name: regions Version: 0.4 Summary: Astropy affilated package for region handling Home-page: http://github.com/astropy/regions Author: Astropy developers Author-email: License: BSD Description: This is an in-development package for region handling based on Astropy. The goal is to merge the functionality from pyregion and photutils apertures and then after some time propose this package for inclusion in the Astropy core. * Code : https://github.com/astropy/regions * Docs : http://astropy-regions.readthedocs.io/en/latest/ Platform: UNKNOWN Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.* Provides-Extra: plot Provides-Extra: test regions-0.4/ah_bootstrap.py0000644000076600000240000011116613476021706016137 0ustar deilstaff00000000000000""" This bootstrap module contains code for ensuring that the astropy_helpers package will be importable by the time the setup.py script runs. It also includes some workarounds to ensure that a recent-enough version of setuptools is being used for the installation. This module should be the first thing imported in the setup.py of distributions that make use of the utilities in astropy_helpers. If the distribution ships with its own copy of astropy_helpers, this module will first attempt to import from the shipped copy. However, it will also check PyPI to see if there are any bug-fix releases on top of the current version that may be useful to get past platform-specific bugs that have been fixed. When running setup.py, use the ``--offline`` command-line option to disable the auto-upgrade checks. When this module is imported or otherwise executed it automatically calls a main function that attempts to read the project's setup.cfg file, which it checks for a configuration section called ``[ah_bootstrap]`` the presences of that section, and options therein, determine the next step taken: If it contains an option called ``auto_use`` with a value of ``True``, it will automatically call the main function of this module called `use_astropy_helpers` (see that function's docstring for full details). Otherwise no further action is taken and by default the system-installed version of astropy-helpers will be used (however, ``ah_bootstrap.use_astropy_helpers`` may be called manually from within the setup.py script). This behavior can also be controlled using the ``--auto-use`` and ``--no-auto-use`` command-line flags. For clarity, an alias for ``--no-auto-use`` is ``--use-system-astropy-helpers``, and we recommend using the latter if needed. Additional options in the ``[ah_boostrap]`` section of setup.cfg have the same names as the arguments to `use_astropy_helpers`, and can be used to configure the bootstrap script when ``auto_use = True``. See https://github.com/astropy/astropy-helpers for more details, and for the latest version of this module. """ import contextlib import errno import io import locale import os import re import subprocess as sp import sys from distutils import log from distutils.debug import DEBUG try: from ConfigParser import ConfigParser, RawConfigParser except ImportError: from configparser import ConfigParser, RawConfigParser import pkg_resources from setuptools import Distribution from setuptools.package_index import PackageIndex # This is the minimum Python version required for astropy-helpers __minimum_python_version__ = (2, 7) if sys.version_info[0] < 3: _str_types = (str, unicode) _text_type = unicode PY3 = False else: _str_types = (str, bytes) _text_type = str PY3 = True # TODO: Maybe enable checking for a specific version of astropy_helpers? DIST_NAME = 'astropy-helpers' PACKAGE_NAME = 'astropy_helpers' if PY3: UPPER_VERSION_EXCLUSIVE = None else: UPPER_VERSION_EXCLUSIVE = '3' # Defaults for other options DOWNLOAD_IF_NEEDED = True INDEX_URL = 'https://pypi.python.org/simple' USE_GIT = True OFFLINE = False AUTO_UPGRADE = True # A list of all the configuration options and their required types CFG_OPTIONS = [ ('auto_use', bool), ('path', str), ('download_if_needed', bool), ('index_url', str), ('use_git', bool), ('offline', bool), ('auto_upgrade', bool) ] # Start off by parsing the setup.cfg file SETUP_CFG = ConfigParser() if os.path.exists('setup.cfg'): try: SETUP_CFG.read('setup.cfg') except Exception as e: if DEBUG: raise log.error( "Error reading setup.cfg: {0!r}\n{1} will not be " "automatically bootstrapped and package installation may fail." "\n{2}".format(e, PACKAGE_NAME, _err_help_msg)) # We used package_name in the package template for a while instead of name if SETUP_CFG.has_option('metadata', 'name'): parent_package = SETUP_CFG.get('metadata', 'name') elif SETUP_CFG.has_option('metadata', 'package_name'): parent_package = SETUP_CFG.get('metadata', 'package_name') else: parent_package = None if SETUP_CFG.has_option('options', 'python_requires'): python_requires = SETUP_CFG.get('options', 'python_requires') # The python_requires key has a syntax that can be parsed by SpecifierSet # in the packaging package. However, we don't want to have to depend on that # package, so instead we can use setuptools (which bundles packaging). We # have to add 'python' to parse it with Requirement. from pkg_resources import Requirement req = Requirement.parse('python' + python_requires) # We want the Python version as a string, which we can get from the platform module import platform # strip off trailing '+' incase this is a dev install of python python_version = platform.python_version().strip('+') # allow pre-releases to count as 'new enough' if not req.specifier.contains(python_version, True): if parent_package is None: print("ERROR: Python {} is required by this package".format(req.specifier)) else: print("ERROR: Python {} is required by {}".format(req.specifier, parent_package)) sys.exit(1) if sys.version_info < __minimum_python_version__: if parent_package is None: print("ERROR: Python {} or later is required by astropy-helpers".format( __minimum_python_version__)) else: print("ERROR: Python {} or later is required by astropy-helpers for {}".format( __minimum_python_version__, parent_package)) sys.exit(1) # What follows are several import statements meant to deal with install-time # issues with either missing or misbehaving pacakges (including making sure # setuptools itself is installed): # Check that setuptools 1.0 or later is present from distutils.version import LooseVersion try: import setuptools assert LooseVersion(setuptools.__version__) >= LooseVersion('1.0') except (ImportError, AssertionError): print("ERROR: setuptools 1.0 or later is required by astropy-helpers") sys.exit(1) # typing as a dependency for 1.6.1+ Sphinx causes issues when imported after # initializing submodule with ah_boostrap.py # See discussion and references in # https://github.com/astropy/astropy-helpers/issues/302 try: import typing # noqa except ImportError: pass # Note: The following import is required as a workaround to # https://github.com/astropy/astropy-helpers/issues/89; if we don't import this # module now, it will get cleaned up after `run_setup` is called, but that will # later cause the TemporaryDirectory class defined in it to stop working when # used later on by setuptools try: import setuptools.py31compat # noqa except ImportError: pass # matplotlib can cause problems if it is imported from within a call of # run_setup(), because in some circumstances it will try to write to the user's # home directory, resulting in a SandboxViolation. See # https://github.com/matplotlib/matplotlib/pull/4165 # Making sure matplotlib, if it is available, is imported early in the setup # process can mitigate this (note importing matplotlib.pyplot has the same # issue) try: import matplotlib matplotlib.use('Agg') import matplotlib.pyplot except: # Ignore if this fails for *any* reason* pass # End compatibility imports... class _Bootstrapper(object): """ Bootstrapper implementation. See ``use_astropy_helpers`` for parameter documentation. """ def __init__(self, path=None, index_url=None, use_git=None, offline=None, download_if_needed=None, auto_upgrade=None): if path is None: path = PACKAGE_NAME if not (isinstance(path, _str_types) or path is False): raise TypeError('path must be a string or False') if PY3 and not isinstance(path, _text_type): fs_encoding = sys.getfilesystemencoding() path = path.decode(fs_encoding) # path to unicode self.path = path # Set other option attributes, using defaults where necessary self.index_url = index_url if index_url is not None else INDEX_URL self.offline = offline if offline is not None else OFFLINE # If offline=True, override download and auto-upgrade if self.offline: download_if_needed = False auto_upgrade = False self.download = (download_if_needed if download_if_needed is not None else DOWNLOAD_IF_NEEDED) self.auto_upgrade = (auto_upgrade if auto_upgrade is not None else AUTO_UPGRADE) # If this is a release then the .git directory will not exist so we # should not use git. git_dir_exists = os.path.exists(os.path.join(os.path.dirname(__file__), '.git')) if use_git is None and not git_dir_exists: use_git = False self.use_git = use_git if use_git is not None else USE_GIT # Declared as False by default--later we check if astropy-helpers can be # upgraded from PyPI, but only if not using a source distribution (as in # the case of import from a git submodule) self.is_submodule = False @classmethod def main(cls, argv=None): if argv is None: argv = sys.argv config = cls.parse_config() config.update(cls.parse_command_line(argv)) auto_use = config.pop('auto_use', False) bootstrapper = cls(**config) if auto_use: # Run the bootstrapper, otherwise the setup.py is using the old # use_astropy_helpers() interface, in which case it will run the # bootstrapper manually after reconfiguring it. bootstrapper.run() return bootstrapper @classmethod def parse_config(cls): if not SETUP_CFG.has_section('ah_bootstrap'): return {} config = {} for option, type_ in CFG_OPTIONS: if not SETUP_CFG.has_option('ah_bootstrap', option): continue if type_ is bool: value = SETUP_CFG.getboolean('ah_bootstrap', option) else: value = SETUP_CFG.get('ah_bootstrap', option) config[option] = value return config @classmethod def parse_command_line(cls, argv=None): if argv is None: argv = sys.argv config = {} # For now we just pop recognized ah_bootstrap options out of the # arg list. This is imperfect; in the unlikely case that a setup.py # custom command or even custom Distribution class defines an argument # of the same name then we will break that. However there's a catch22 # here that we can't just do full argument parsing right here, because # we don't yet know *how* to parse all possible command-line arguments. if '--no-git' in argv: config['use_git'] = False argv.remove('--no-git') if '--offline' in argv: config['offline'] = True argv.remove('--offline') if '--auto-use' in argv: config['auto_use'] = True argv.remove('--auto-use') if '--no-auto-use' in argv: config['auto_use'] = False argv.remove('--no-auto-use') if '--use-system-astropy-helpers' in argv: config['auto_use'] = False argv.remove('--use-system-astropy-helpers') return config def run(self): strategies = ['local_directory', 'local_file', 'index'] dist = None # First, remove any previously imported versions of astropy_helpers; # this is necessary for nested installs where one package's installer # is installing another package via setuptools.sandbox.run_setup, as in # the case of setup_requires for key in list(sys.modules): try: if key == PACKAGE_NAME or key.startswith(PACKAGE_NAME + '.'): del sys.modules[key] except AttributeError: # Sometimes mysterious non-string things can turn up in # sys.modules continue # Check to see if the path is a submodule self.is_submodule = self._check_submodule() for strategy in strategies: method = getattr(self, 'get_{0}_dist'.format(strategy)) dist = method() if dist is not None: break else: raise _AHBootstrapSystemExit( "No source found for the {0!r} package; {0} must be " "available and importable as a prerequisite to building " "or installing this package.".format(PACKAGE_NAME)) # This is a bit hacky, but if astropy_helpers was loaded from a # directory/submodule its Distribution object gets a "precedence" of # "DEVELOP_DIST". However, in other cases it gets a precedence of # "EGG_DIST". However, when activing the distribution it will only be # placed early on sys.path if it is treated as an EGG_DIST, so always # do that dist = dist.clone(precedence=pkg_resources.EGG_DIST) # Otherwise we found a version of astropy-helpers, so we're done # Just active the found distribution on sys.path--if we did a # download this usually happens automatically but it doesn't hurt to # do it again # Note: Adding the dist to the global working set also activates it # (makes it importable on sys.path) by default. try: pkg_resources.working_set.add(dist, replace=True) except TypeError: # Some (much) older versions of setuptools do not have the # replace=True option here. These versions are old enough that all # bets may be off anyways, but it's easy enough to work around just # in case... if dist.key in pkg_resources.working_set.by_key: del pkg_resources.working_set.by_key[dist.key] pkg_resources.working_set.add(dist) @property def config(self): """ A `dict` containing the options this `_Bootstrapper` was configured with. """ return dict((optname, getattr(self, optname)) for optname, _ in CFG_OPTIONS if hasattr(self, optname)) def get_local_directory_dist(self): """ Handle importing a vendored package from a subdirectory of the source distribution. """ if not os.path.isdir(self.path): return log.info('Attempting to import astropy_helpers from {0} {1!r}'.format( 'submodule' if self.is_submodule else 'directory', self.path)) dist = self._directory_import() if dist is None: log.warn( 'The requested path {0!r} for importing {1} does not ' 'exist, or does not contain a copy of the {1} ' 'package.'.format(self.path, PACKAGE_NAME)) elif self.auto_upgrade and not self.is_submodule: # A version of astropy-helpers was found on the available path, but # check to see if a bugfix release is available on PyPI upgrade = self._do_upgrade(dist) if upgrade is not None: dist = upgrade return dist def get_local_file_dist(self): """ Handle importing from a source archive; this also uses setup_requires but points easy_install directly to the source archive. """ if not os.path.isfile(self.path): return log.info('Attempting to unpack and import astropy_helpers from ' '{0!r}'.format(self.path)) try: dist = self._do_download(find_links=[self.path]) except Exception as e: if DEBUG: raise log.warn( 'Failed to import {0} from the specified archive {1!r}: ' '{2}'.format(PACKAGE_NAME, self.path, str(e))) dist = None if dist is not None and self.auto_upgrade: # A version of astropy-helpers was found on the available path, but # check to see if a bugfix release is available on PyPI upgrade = self._do_upgrade(dist) if upgrade is not None: dist = upgrade return dist def get_index_dist(self): if not self.download: log.warn('Downloading {0!r} disabled.'.format(DIST_NAME)) return None log.warn( "Downloading {0!r}; run setup.py with the --offline option to " "force offline installation.".format(DIST_NAME)) try: dist = self._do_download() except Exception as e: if DEBUG: raise log.warn( 'Failed to download and/or install {0!r} from {1!r}:\n' '{2}'.format(DIST_NAME, self.index_url, str(e))) dist = None # No need to run auto-upgrade here since we've already presumably # gotten the most up-to-date version from the package index return dist def _directory_import(self): """ Import astropy_helpers from the given path, which will be added to sys.path. Must return True if the import succeeded, and False otherwise. """ # Return True on success, False on failure but download is allowed, and # otherwise raise SystemExit path = os.path.abspath(self.path) # Use an empty WorkingSet rather than the man # pkg_resources.working_set, since on older versions of setuptools this # will invoke a VersionConflict when trying to install an upgrade ws = pkg_resources.WorkingSet([]) ws.add_entry(path) dist = ws.by_key.get(DIST_NAME) if dist is None: # We didn't find an egg-info/dist-info in the given path, but if a # setup.py exists we can generate it setup_py = os.path.join(path, 'setup.py') if os.path.isfile(setup_py): # We use subprocess instead of run_setup from setuptools to # avoid segmentation faults - see the following for more details: # https://github.com/cython/cython/issues/2104 sp.check_output([sys.executable, 'setup.py', 'egg_info'], cwd=path) for dist in pkg_resources.find_distributions(path, True): # There should be only one... return dist return dist def _do_download(self, version='', find_links=None): if find_links: allow_hosts = '' index_url = None else: allow_hosts = None index_url = self.index_url # Annoyingly, setuptools will not handle other arguments to # Distribution (such as options) before handling setup_requires, so it # is not straightforward to programmatically augment the arguments which # are passed to easy_install class _Distribution(Distribution): def get_option_dict(self, command_name): opts = Distribution.get_option_dict(self, command_name) if command_name == 'easy_install': if find_links is not None: opts['find_links'] = ('setup script', find_links) if index_url is not None: opts['index_url'] = ('setup script', index_url) if allow_hosts is not None: opts['allow_hosts'] = ('setup script', allow_hosts) return opts if version: req = '{0}=={1}'.format(DIST_NAME, version) else: if UPPER_VERSION_EXCLUSIVE is None: req = DIST_NAME else: req = '{0}<{1}'.format(DIST_NAME, UPPER_VERSION_EXCLUSIVE) attrs = {'setup_requires': [req]} # NOTE: we need to parse the config file (e.g. setup.cfg) to make sure # it honours the options set in the [easy_install] section, and we need # to explicitly fetch the requirement eggs as setup_requires does not # get honored in recent versions of setuptools: # https://github.com/pypa/setuptools/issues/1273 try: context = _verbose if DEBUG else _silence with context(): dist = _Distribution(attrs=attrs) try: dist.parse_config_files(ignore_option_errors=True) dist.fetch_build_eggs(req) except TypeError: # On older versions of setuptools, ignore_option_errors # doesn't exist, and the above two lines are not needed # so we can just continue pass # If the setup_requires succeeded it will have added the new dist to # the main working_set return pkg_resources.working_set.by_key.get(DIST_NAME) except Exception as e: if DEBUG: raise msg = 'Error retrieving {0} from {1}:\n{2}' if find_links: source = find_links[0] elif index_url != INDEX_URL: source = index_url else: source = 'PyPI' raise Exception(msg.format(DIST_NAME, source, repr(e))) def _do_upgrade(self, dist): # Build up a requirement for a higher bugfix release but a lower minor # release (so API compatibility is guaranteed) next_version = _next_version(dist.parsed_version) req = pkg_resources.Requirement.parse( '{0}>{1},<{2}'.format(DIST_NAME, dist.version, next_version)) package_index = PackageIndex(index_url=self.index_url) upgrade = package_index.obtain(req) if upgrade is not None: return self._do_download(version=upgrade.version) def _check_submodule(self): """ Check if the given path is a git submodule. See the docstrings for ``_check_submodule_using_git`` and ``_check_submodule_no_git`` for further details. """ if (self.path is None or (os.path.exists(self.path) and not os.path.isdir(self.path))): return False if self.use_git: return self._check_submodule_using_git() else: return self._check_submodule_no_git() def _check_submodule_using_git(self): """ Check if the given path is a git submodule. If so, attempt to initialize and/or update the submodule if needed. This function makes calls to the ``git`` command in subprocesses. The ``_check_submodule_no_git`` option uses pure Python to check if the given path looks like a git submodule, but it cannot perform updates. """ cmd = ['git', 'submodule', 'status', '--', self.path] try: log.info('Running `{0}`; use the --no-git option to disable git ' 'commands'.format(' '.join(cmd))) returncode, stdout, stderr = run_cmd(cmd) except _CommandNotFound: # The git command simply wasn't found; this is most likely the # case on user systems that don't have git and are simply # trying to install the package from PyPI or a source # distribution. Silently ignore this case and simply don't try # to use submodules return False stderr = stderr.strip() if returncode != 0 and stderr: # Unfortunately the return code alone cannot be relied on, as # earlier versions of git returned 0 even if the requested submodule # does not exist # This is a warning that occurs in perl (from running git submodule) # which only occurs with a malformatted locale setting which can # happen sometimes on OSX. See again # https://github.com/astropy/astropy/issues/2749 perl_warning = ('perl: warning: Falling back to the standard locale ' '("C").') if not stderr.strip().endswith(perl_warning): # Some other unknown error condition occurred log.warn('git submodule command failed ' 'unexpectedly:\n{0}'.format(stderr)) return False # Output of `git submodule status` is as follows: # # 1: Status indicator: '-' for submodule is uninitialized, '+' if # submodule is initialized but is not at the commit currently indicated # in .gitmodules (and thus needs to be updated), or 'U' if the # submodule is in an unstable state (i.e. has merge conflicts) # # 2. SHA-1 hash of the current commit of the submodule (we don't really # need this information but it's useful for checking that the output is # correct) # # 3. The output of `git describe` for the submodule's current commit # hash (this includes for example what branches the commit is on) but # only if the submodule is initialized. We ignore this information for # now _git_submodule_status_re = re.compile( r'^(?P[+-U ])(?P[0-9a-f]{40}) ' r'(?P\S+)( .*)?$') # The stdout should only contain one line--the status of the # requested submodule m = _git_submodule_status_re.match(stdout) if m: # Yes, the path *is* a git submodule self._update_submodule(m.group('submodule'), m.group('status')) return True else: log.warn( 'Unexpected output from `git submodule status`:\n{0}\n' 'Will attempt import from {1!r} regardless.'.format( stdout, self.path)) return False def _check_submodule_no_git(self): """ Like ``_check_submodule_using_git``, but simply parses the .gitmodules file to determine if the supplied path is a git submodule, and does not exec any subprocesses. This can only determine if a path is a submodule--it does not perform updates, etc. This function may need to be updated if the format of the .gitmodules file is changed between git versions. """ gitmodules_path = os.path.abspath('.gitmodules') if not os.path.isfile(gitmodules_path): return False # This is a minimal reader for gitconfig-style files. It handles a few of # the quirks that make gitconfig files incompatible with ConfigParser-style # files, but does not support the full gitconfig syntax (just enough # needed to read a .gitmodules file). gitmodules_fileobj = io.StringIO() # Must use io.open for cross-Python-compatible behavior wrt unicode with io.open(gitmodules_path) as f: for line in f: # gitconfig files are more flexible with leading whitespace; just # go ahead and remove it line = line.lstrip() # comments can start with either # or ; if line and line[0] in (':', ';'): continue gitmodules_fileobj.write(line) gitmodules_fileobj.seek(0) cfg = RawConfigParser() try: cfg.readfp(gitmodules_fileobj) except Exception as exc: log.warn('Malformatted .gitmodules file: {0}\n' '{1} cannot be assumed to be a git submodule.'.format( exc, self.path)) return False for section in cfg.sections(): if not cfg.has_option(section, 'path'): continue submodule_path = cfg.get(section, 'path').rstrip(os.sep) if submodule_path == self.path.rstrip(os.sep): return True return False def _update_submodule(self, submodule, status): if status == ' ': # The submodule is up to date; no action necessary return elif status == '-': if self.offline: raise _AHBootstrapSystemExit( "Cannot initialize the {0} submodule in --offline mode; " "this requires being able to clone the submodule from an " "online repository.".format(submodule)) cmd = ['update', '--init'] action = 'Initializing' elif status == '+': cmd = ['update'] action = 'Updating' if self.offline: cmd.append('--no-fetch') elif status == 'U': raise _AHBootstrapSystemExit( 'Error: Submodule {0} contains unresolved merge conflicts. ' 'Please complete or abandon any changes in the submodule so that ' 'it is in a usable state, then try again.'.format(submodule)) else: log.warn('Unknown status {0!r} for git submodule {1!r}. Will ' 'attempt to use the submodule as-is, but try to ensure ' 'that the submodule is in a clean state and contains no ' 'conflicts or errors.\n{2}'.format(status, submodule, _err_help_msg)) return err_msg = None cmd = ['git', 'submodule'] + cmd + ['--', submodule] log.warn('{0} {1} submodule with: `{2}`'.format( action, submodule, ' '.join(cmd))) try: log.info('Running `{0}`; use the --no-git option to disable git ' 'commands'.format(' '.join(cmd))) returncode, stdout, stderr = run_cmd(cmd) except OSError as e: err_msg = str(e) else: if returncode != 0: err_msg = stderr if err_msg is not None: log.warn('An unexpected error occurred updating the git submodule ' '{0!r}:\n{1}\n{2}'.format(submodule, err_msg, _err_help_msg)) class _CommandNotFound(OSError): """ An exception raised when a command run with run_cmd is not found on the system. """ def run_cmd(cmd): """ Run a command in a subprocess, given as a list of command-line arguments. Returns a ``(returncode, stdout, stderr)`` tuple. """ try: p = sp.Popen(cmd, stdout=sp.PIPE, stderr=sp.PIPE) # XXX: May block if either stdout or stderr fill their buffers; # however for the commands this is currently used for that is # unlikely (they should have very brief output) stdout, stderr = p.communicate() except OSError as e: if DEBUG: raise if e.errno == errno.ENOENT: msg = 'Command not found: `{0}`'.format(' '.join(cmd)) raise _CommandNotFound(msg, cmd) else: raise _AHBootstrapSystemExit( 'An unexpected error occurred when running the ' '`{0}` command:\n{1}'.format(' '.join(cmd), str(e))) # Can fail of the default locale is not configured properly. See # https://github.com/astropy/astropy/issues/2749. For the purposes under # consideration 'latin1' is an acceptable fallback. try: stdio_encoding = locale.getdefaultlocale()[1] or 'latin1' except ValueError: # Due to an OSX oddity locale.getdefaultlocale() can also crash # depending on the user's locale/language settings. See: # http://bugs.python.org/issue18378 stdio_encoding = 'latin1' # Unlikely to fail at this point but even then let's be flexible if not isinstance(stdout, _text_type): stdout = stdout.decode(stdio_encoding, 'replace') if not isinstance(stderr, _text_type): stderr = stderr.decode(stdio_encoding, 'replace') return (p.returncode, stdout, stderr) def _next_version(version): """ Given a parsed version from pkg_resources.parse_version, returns a new version string with the next minor version. Examples ======== >>> _next_version(pkg_resources.parse_version('1.2.3')) '1.3.0' """ if hasattr(version, 'base_version'): # New version parsing from setuptools >= 8.0 if version.base_version: parts = version.base_version.split('.') else: parts = [] else: parts = [] for part in version: if part.startswith('*'): break parts.append(part) parts = [int(p) for p in parts] if len(parts) < 3: parts += [0] * (3 - len(parts)) major, minor, micro = parts[:3] return '{0}.{1}.{2}'.format(major, minor + 1, 0) class _DummyFile(object): """A noop writeable object.""" errors = '' # Required for Python 3.x encoding = 'utf-8' def write(self, s): pass def flush(self): pass @contextlib.contextmanager def _verbose(): yield @contextlib.contextmanager def _silence(): """A context manager that silences sys.stdout and sys.stderr.""" old_stdout = sys.stdout old_stderr = sys.stderr sys.stdout = _DummyFile() sys.stderr = _DummyFile() exception_occurred = False try: yield except: exception_occurred = True # Go ahead and clean up so that exception handling can work normally sys.stdout = old_stdout sys.stderr = old_stderr raise if not exception_occurred: sys.stdout = old_stdout sys.stderr = old_stderr _err_help_msg = """ If the problem persists consider installing astropy_helpers manually using pip (`pip install astropy_helpers`) or by manually downloading the source archive, extracting it, and installing by running `python setup.py install` from the root of the extracted source code. """ class _AHBootstrapSystemExit(SystemExit): def __init__(self, *args): if not args: msg = 'An unknown problem occurred bootstrapping astropy_helpers.' else: msg = args[0] msg += '\n' + _err_help_msg super(_AHBootstrapSystemExit, self).__init__(msg, *args[1:]) BOOTSTRAPPER = _Bootstrapper.main() def use_astropy_helpers(**kwargs): """ Ensure that the `astropy_helpers` module is available and is importable. This supports automatic submodule initialization if astropy_helpers is included in a project as a git submodule, or will download it from PyPI if necessary. Parameters ---------- path : str or None, optional A filesystem path relative to the root of the project's source code that should be added to `sys.path` so that `astropy_helpers` can be imported from that path. If the path is a git submodule it will automatically be initialized and/or updated. The path may also be to a ``.tar.gz`` archive of the astropy_helpers source distribution. In this case the archive is automatically unpacked and made temporarily available on `sys.path` as a ``.egg`` archive. If `None` skip straight to downloading. download_if_needed : bool, optional If the provided filesystem path is not found an attempt will be made to download astropy_helpers from PyPI. It will then be made temporarily available on `sys.path` as a ``.egg`` archive (using the ``setup_requires`` feature of setuptools. If the ``--offline`` option is given at the command line the value of this argument is overridden to `False`. index_url : str, optional If provided, use a different URL for the Python package index than the main PyPI server. use_git : bool, optional If `False` no git commands will be used--this effectively disables support for git submodules. If the ``--no-git`` option is given at the command line the value of this argument is overridden to `False`. auto_upgrade : bool, optional By default, when installing a package from a non-development source distribution ah_boostrap will try to automatically check for patch releases to astropy-helpers on PyPI and use the patched version over any bundled versions. Setting this to `False` will disable that functionality. If the ``--offline`` option is given at the command line the value of this argument is overridden to `False`. offline : bool, optional If `False` disable all actions that require an internet connection, including downloading packages from the package index and fetching updates to any git submodule. Defaults to `True`. """ global BOOTSTRAPPER config = BOOTSTRAPPER.config config.update(**kwargs) # Create a new bootstrapper with the updated configuration and run it BOOTSTRAPPER = _Bootstrapper(**config) BOOTSTRAPPER.run() regions-0.4/astropy_helpers/0000755000076600000240000000000013501657425016317 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/.travis.yml0000644000076600000240000000615413467311012020424 0ustar deilstaff00000000000000# We set the language to c because python isn't supported on the MacOS X nodes # on Travis. However, the language ends up being irrelevant anyway, since we # install Python ourselves using conda. language: c os: - osx - linux # Setting sudo to false opts in to Travis-CI container-based builds. sudo: false env: matrix: - PYTHON_VERSION=2.7 EVENT_TYPE='push pull_request cron' - PYTHON_VERSION=3.4 SETUPTOOLS_VERSION=20 - PYTHON_VERSION=3.5 - PYTHON_VERSION=3.6 - PYTHON_VERSION=3.7 SETUPTOOLS_VERSION=dev DEBUG=True CONDA_DEPENDENCIES='sphinx cython numpy six pytest-cov' EVENT_TYPE='push pull_request cron' global: - CONDA_DEPENDENCIES="setuptools sphinx cython numpy" - PIP_DEPENDENCIES="coveralls pytest-cov" - EVENT_TYPE='push pull_request' matrix: include: - os: linux env: PYTHON_VERSION=3.6 SPHINX_VERSION='>1.6' - os: linux env: PYTHON_VERSION=3.6 PIP_DEPENDENCIES='git+https://github.com/sphinx-doc/sphinx.git#egg=sphinx coveralls pytest-cov' CONDA_DEPENDENCIES="setuptools cython numpy" - os: linux env: PYTHON_VERSION=3.5 SPHINX_VERSION='<1.4' - os: linux env: PYTHON_VERSION=3.5 SPHINX_VERSION='<1.5' SETUPTOOLS_VERSION=27 - os: linux env: PYTHON_VERSION=3.6 SPHINX_VERSION='<1.6' SETUPTOOLS_VERSION=27 # Test without installing numpy beforehand to make sure everything works # without assuming numpy is already installed - os: linux env: PYTHON_VERSION=3.6 CONDA_DEPENDENCIES='sphinx cython six pytest-cov' # Uncomment the following if there are issues in setuptools that we # can't work around quickly - otherwise leave uncommented so that # we notice when things go wrong. # # allow_failures: # - env: PYTHON_VERSION=3.6 SETUPTOOLS_VERSION=dev DEBUG=True # CONDA_DEPENDENCIES='sphinx cython numpy six pytest-cov' # EVENT_TYPE='push pull_request cron' install: - git clone git://github.com/astropy/ci-helpers.git - source ci-helpers/travis/setup_conda.sh # We cannot install the developer version of setuptools using pip because # pip tries to remove the previous version of setuptools before the # installation is complete, which causes issues. Instead, we just install # setuptools manually. - if [[ $SETUPTOOLS_VERSION == dev ]]; then git clone http://github.com/pypa/setuptools.git; cd setuptools; python bootstrap.py; python setup.py install; cd ..; fi before_script: # Some of the tests use git commands that require a user to be configured - git config --global user.name "A U Thor" - git config --global user.email "author@example.com" script: # Use full path for coveragerc; see issue #193 - py.test --cov astropy_helpers --cov-config $(pwd)/astropy_helpers/tests/coveragerc astropy_helpers # In conftest.py we produce a .coverage.subprocess that contains coverage # statistics for sub-processes, so we combine it with the main one here. - mv .coverage .coverage.main - coverage combine .coverage.main .coverage.subprocess - coverage report after_success: - coveralls --rcfile=astropy_helpers/tests/coveragerc regions-0.4/astropy_helpers/CHANGES.rst0000644000076600000240000004336613477530461020137 0ustar deilstaff00000000000000astropy-helpers Changelog ************************* 2.0.10 (2019-05-29) ------------------- - Removed ``tocdepthfix`` sphinx extension that worked around a big in Sphinx that has been long fixed. [#475] - Allow Python dev versions to pass the python version check. [#476] - Updated bundled version of sphinx-automodapi to v0.11. [#478] 2.0.9 (2019-02-22) ------------------ - Updated bundled version of sphinx-automodapi to v0.10. [#439] - Updated bundled sphinx extensions version to sphinx-astropy v1.1.1. [#454] - Include package name in error message for Python version in ``ah_bootstrap.py``. [#441] 2.0.8 (2018-12-04) ------------------ - Fixed compatibility with Sphinx 1.8+. [#428] - Fixed error that occurs when installing a package in an environment where ``numpy`` is not already installed. [#404] - Updated bundled version of sphinx-automodapi to v0.9. [#422] - Updated bundled version of numpydoc to v0.8.0. [#423] 2.0.7 (2018-06-01) ------------------ - Removing ez_setup.py file and requiring setuptools 1.0 or later. [#384] 2.0.6 (2018-02-24) ------------------ - Avoid deprecation warning due to ``exclude=`` keyword in ``setup.py``. [#379] 2.0.5 (2018-02-22) ------------------ - Fix segmentation faults that occurred when the astropy-helpers submodule was first initialized in packages that also contained Cython code. [#375] 2.0.4 (2018-02-09) ------------------ - Support dotted package names as namespace packages in generate_version_py. [#370] - Fix compatibility with setuptools 36.x and above. [#372] - Fix false negative in add_openmp_flags_if_available when measuring code coverage with gcc. [#374] 2.0.3 (2018-01-20) ------------------ - Make sure that astropy-helpers 3.x.x is not downloaded on Python 2. [#363] - The bundled version of sphinx-automodapi has been updated to v0.7. [#365] - Add --auto-use and --no-auto-use command-line flags to match the ``auto_use`` configuration option, and add an alias ``--use-system-astropy-helpers`` for ``--no-auto-use``. [#366] 2.0.2 (2017-10-13) ------------------ - Added new helper function add_openmp_flags_if_available that can add OpenMP compilation flags to a C/Cython extension if needed. [#346] - Update numpydoc to v0.7. [#343] - The function ``get_git_devstr`` now returns ``'0'`` instead of ``None`` when no git repository is present. This allows generation of development version strings that are in a format that ``setuptools`` expects (e.g. "1.1.3.dev0" instead of "1.1.3.dev"). [#330] - It is now possible to override generated timestamps to make builds reproducible by setting the ``SOURCE_DATE_EPOCH`` environment variable [#341] - Mark Sphinx extensions as parallel-safe. [#344] - Switch to using mathjax instead of imgmath for local builds. [#342] - Deprecate ``exclude`` parameter of various functions in setup_helpers since it could not work as intended. Add new function ``add_exclude_packages`` to provide intended behavior. [#331] - Allow custom Sphinx doctest extension to recognize and process standard doctest directives ``testsetup`` and ``doctest``. [#335] 2.0.1 (2017-07-28) ------------------ - Fix compatibility with Sphinx <1.5. [#326] 2.0 (2017-07-06) ---------------- - Add support for package that lies in a subdirectory. [#249] - Removing ``compat.subprocess``. [#298] - Python 3.3 is no longer supported. [#300] - The 'automodapi' Sphinx extension (and associated dependencies) has now been moved to a standalone package which can be found at https://github.com/astropy/sphinx-automodapi - this is now bundled in astropy-helpers under astropy_helpers.extern.automodapi for convenience. Version shipped with astropy-helpers is v0.6. [#278, #303, #309, #323] - The ``numpydoc`` Sphinx extension has now been moved to ``astropy_helpers.extern``. [#278] - Fix ``build_docs`` error catching, so it doesn't hide Sphinx errors. [#292] - Fix compatibility with Sphinx 1.6. [#318] - Updating ez_setup.py to the last version before it's removal. [#321] 1.3.1 (2017-03-18) ------------------ - Fixed the missing button to hide output in documentation code blocks. [#287] - Fixed bug when ``build_docs`` when running with the clean (-l) option. [#289] - Add alternative location for various intersphinx inventories to fall back to. [#293] 1.3 (2016-12-16) ---------------- - ``build_sphinx`` has been deprecated in favor of the ``build_docs`` command. [#246] - Force the use of Cython's old ``build_ext`` command. A new ``build_ext`` command was added in Cython 0.25, but it does not work with astropy-helpers currently. [#261] 1.2 (2016-06-18) ---------------- - Added sphinx configuration value ``automodsumm_inherited_members``. If ``True`` this will include members that are inherited from a base class in the generated API docs. Defaults to ``False`` which matches the previous behavior. [#215] - Fixed ``build_sphinx`` to recognize builds that succeeded but have output *after* the "build succeeded." statement. This only applies when ``--warnings-returncode`` is given (which is primarily relevant for Travis documentation builds). [#223] - Fixed ``build_sphinx`` the sphinx extensions to not output a spurious warning for sphinx versions > 1.4. [#229] - Add Python version dependent local sphinx inventories that contain otherwise missing references. [#216] - ``astropy_helpers`` now require Sphinx 1.3 or later. [#226] 1.1.2 (2016-03-9) ----------------- - The CSS for the sphinx documentation was altered to prevent some text overflow problems. [#217] 1.1.1 (2015-12-23) ------------------ - Fixed crash in build with ``AttributeError: cython_create_listing`` with older versions of setuptools. [#209, #210] 1.1 (2015-12-10) ---------------- - The original ``AstropyTest`` class in ``astropy_helpers``, which implements the ``setup.py test`` command, is deprecated in favor of moving the implementation of that command closer to the actual Astropy test runner in ``astropy.tests``. Now a dummy ``test`` command is provided solely for informing users that they need ``astropy`` installed to run the tests (however, the previous, now deprecated implementation is still provided and continues to work with older versions of Astropy). See the related issue for more details. [#184] - Added a useful new utility function to ``astropy_helpers.utils`` called ``find_data_files``. This is similar to the ``find_packages`` function in setuptools in that it can be used to search a package for data files (matching a pattern) that can be passed to the ``package_data`` argument for ``setup()``. See the docstring to ``astropy_helpers.utils.find_data_files`` for more details. [#42] - The ``astropy_helpers`` module now sets the global ``_ASTROPY_SETUP_`` flag upon import (from within a ``setup.py``) script, so it's not necessary to have this in the ``setup.py`` script explicitly. If in doubt though, there's no harm in setting it twice. Putting it in ``astropy_helpers`` just ensures that any other imports that occur during build will have this flag set. [#191] - It is now possible to use Cython as a ``setup_requires`` build requirement, and still build Cython extensions even if Cython wasn't available at the beginning of the build processes (that is, is automatically downloaded via setuptools' processing of ``setup_requires``). [#185] - Moves the ``adjust_compiler`` check into the ``build_ext`` command itself, so it's only used when actually building extension modules. This also deprecates the stand-alone ``adjust_compiler`` function. [#76] - When running the ``build_sphinx`` / ``build_docs`` command with the ``-w`` option, the output from Sphinx is streamed as it runs instead of silently buffering until the doc build is complete. [#197] 1.0.7 (unreleased) ------------------ - Fix missing import in ``astropy_helpers/utils.py``. [#196] 1.0.6 (2015-12-04) ------------------ - Fixed bug where running ``./setup.py build_sphinx`` could return successfully even when the build was not successful (and should have returned a non-zero error code). [#199] 1.0.5 (2015-10-02) ------------------ - Fixed a regression in the ``./setup.py test`` command that was introduced in v1.0.4. 1.0.4 (2015-10-02) ------------------ - Fixed issue with the sphinx documentation css where the line numbers for code blocks were not aligned with the code. [#179, #180] - Fixed crash that could occur when trying to build Cython extension modules when Cython isn't installed. Normally this still results in a failed build, but was supposed to provide a useful error message rather than crash outright (this was a regression introduced in v1.0.3). [#181] - Fixed a crash that could occur on Python 3 when a working C compiler isn't found. [#182] - Quieted warnings about deprecated Numpy API in Cython extensions, when building Cython extensions against Numpy >= 1.7. [#183, #186] - Improved support for py.test >= 2.7--running the ``./setup.py test`` command now copies all doc pages into the temporary test directory as well, so that all test files have a "common root directory". [#189, #190] 1.0.3 (2015-07-22) ------------------ - Added workaround for sphinx-doc/sphinx#1843, a but in Sphinx which prevented descriptor classes with a custom metaclass from being documented correctly. [#158] - Added an alias for the ``./setup.py build_sphinx`` command as ``./setup.py build_docs`` which, to a new contributor, should hopefully be less cryptic. [#161] - The fonts in graphviz diagrams now match the font of the HTML content. [#169] - When the documentation is built on readthedocs.org, MathJax will be used for math rendering. When built elsewhere, the "pngmath" extension is still used for math rendering. [#170] - Fix crash when importing astropy_helpers when running with ``python -OO`` [#171] - The ``build`` and ``build_ext`` stages now correctly recognize the presence of C++ files in Cython extensions (previously only vanilla C worked). [#173] 1.0.2 (2015-04-02) ------------------ - Various fixes enabling the astropy-helpers Sphinx build command and Sphinx extensions to work with Sphinx 1.3. [#148] - More improvement to the ability to handle multiple versions of astropy-helpers being imported in the same Python interpreter session in the (somewhat rare) case of nested installs. [#147] - To better support high resolution displays, use SVG for the astropy logo and linkout image, falling back to PNGs for browsers that support it. [#150, #151] - Improve ``setup_helpers.get_compiler_version`` to work with more compilers, and to return more info. This will help fix builds of Astropy on less common compilers, like Sun C. [#153] 1.0.1 (2015-03-04) ------------------ - Released in concert with v0.4.8 to address the same issues. 0.4.8 (2015-03-04) ------------------ - Improved the ``ah_bootstrap`` script's ability to override existing installations of astropy-helpers with new versions in the context of installing multiple packages simultaneously within the same Python interpreter (e.g. when one package has in its ``setup_requires`` another package that uses a different version of astropy-helpers. [#144] - Added a workaround to an issue in matplotlib that can, in rare cases, lead to a crash when installing packages that import matplotlib at build time. [#144] 1.0 (2015-02-17) ---------------- - Added new pre-/post-command hook points for ``setup.py`` commands. Now any package can define code to run before and/or after any ``setup.py`` command without having to manually subclass that command by adding ``pre__hook`` and ``post__hook`` callables to the package's ``setup_package.py`` module. See the PR for more details. [#112] - The following objects in the ``astropy_helpers.setup_helpers`` module have been relocated: - ``get_dummy_distribution``, ``get_distutils_*``, ``get_compiler_option``, ``add_command_option``, ``is_distutils_display_option`` -> ``astropy_helpers.distutils_helpers`` - ``should_build_with_cython``, ``generate_build_ext_command`` -> ``astropy_helpers.commands.build_ext`` - ``AstropyBuildPy`` -> ``astropy_helpers.commands.build_py`` - ``AstropyBuildSphinx`` -> ``astropy_helpers.commands.build_sphinx`` - ``AstropyInstall`` -> ``astropy_helpers.commands.install`` - ``AstropyInstallLib`` -> ``astropy_helpers.commands.install_lib`` - ``AstropyRegister`` -> ``astropy_helpers.commands.register`` - ``get_pkg_version_module`` -> ``astropy_helpers.version_helpers`` - ``write_if_different``, ``import_file``, ``get_numpy_include_path`` -> ``astropy_helpers.utils`` All of these are "soft" deprecations in the sense that they are still importable from ``astropy_helpers.setup_helpers`` for now, and there is no (easy) way to produce deprecation warnings when importing these objects from ``setup_helpers`` rather than directly from the modules they are defined in. But please consider updating any imports to these objects. [#110] - Use of the ``astropy.sphinx.ext.astropyautosummary`` extension is deprecated for use with Sphinx < 1.2. Instead it should suffice to remove this extension for the ``extensions`` list in your ``conf.py`` and add the stock ``sphinx.ext.autosummary`` instead. [#131] 0.4.7 (2015-02-17) ------------------ - Fixed incorrect/missing git hash being added to the generated ``version.py`` when creating a release. [#141] 0.4.6 (2015-02-16) ------------------ - Fixed problems related to the automatically generated _compiler module not being created properly. [#139] 0.4.5 (2015-02-11) ------------------ - Fixed an issue where ah_bootstrap.py could blow up when astropy_helper's version number is 1.0. - Added a workaround for documentation of properties in the rare case where the class's metaclass has a property of the same name. [#130] - Fixed an issue on Python 3 where importing a package using astropy-helper's generated version.py module would crash when the current working directory is an empty git repository. [#114, #137] - Fixed an issue where the "revision count" appended to .dev versions by the generated version.py did not accurately reflect the revision count for the package it belongs to, and could be invalid if the current working directory is an unrelated git repository. [#107, #137] - Likewise, fixed a confusing warning message that could occur in the same circumstances as the above issue. [#121, #137] 0.4.4 (2014-12-31) ------------------ - More improvements for building the documentation using Python 3.x. [#100] - Additional minor fixes to Python 3 support. [#115] - Updates to support new test features in Astropy [#92, #106] 0.4.3 (2014-10-22) ------------------ - The generated ``version.py`` file now preserves the git hash of installed copies of the package as well as when building a source distribution. That is, the git hash of the changeset that was installed/released is preserved. [#87] - In smart resolver add resolution for class links when they exist in the intersphinx inventory, but not the mapping of the current package (e.g. when an affiliated package uses an astropy core class of which "actual" and "documented" location differs) [#88] - Fixed a bug that could occur when running ``setup.py`` for the first time in a repository that uses astropy-helpers as a submodule: ``AttributeError: 'NoneType' object has no attribute 'mkdtemp'`` [#89] - Fixed a bug where optional arguments to the ``doctest-skip`` Sphinx directive were sometimes being left in the generated documentation output. [#90] - Improved support for building the documentation using Python 3.x. [#96] - Avoid error message if .git directory is not present. [#91] 0.4.2 (2014-08-09) ------------------ - Fixed some CSS issues in generated API docs. [#69] - Fixed the warning message that could be displayed when generating a version number with some older versions of git. [#77] - Fixed automodsumm to work with new versions of Sphinx (>= 1.2.2). [#80] 0.4.1 (2014-08-08) ------------------ - Fixed git revision count on systems with git versions older than v1.7.2. [#70] - Fixed display of warning text when running a git command fails (previously the output of stderr was not being decoded properly). [#70] - The ``--offline`` flag to ``setup.py`` understood by ``ah_bootstrap.py`` now also prevents git from going online to fetch submodule updates. [#67] - The Sphinx extension for converting issue numbers to links in the changelog now supports working on arbitrary pages via a new ``conf.py`` setting: ``changelog_links_docpattern``. By default it affects the ``changelog`` and ``whatsnew`` pages in one's Sphinx docs. [#61] - Fixed crash that could result from users with missing/misconfigured locale settings. [#58] - The font used for code examples in the docs is now the system-defined ``monospace`` font, rather than ``Minaco``, which is not available on all platforms. [#50] 0.4 (2014-07-15) ---------------- - Initial release of astropy-helpers. See `APE4 `_ for details of the motivation and design of this package. - The ``astropy_helpers`` package replaces the following modules in the ``astropy`` package: - ``astropy.setup_helpers`` -> ``astropy_helpers.setup_helpers`` - ``astropy.version_helpers`` -> ``astropy_helpers.version_helpers`` - ``astropy.sphinx`` - > ``astropy_helpers.sphinx`` These modules should be considered deprecated in ``astropy``, and any new, non-critical changes to those modules will be made in ``astropy_helpers`` instead. Affiliated packages wishing to make use those modules (as in the Astropy package-template) should use the versions from ``astropy_helpers`` instead, and include the ``ah_bootstrap.py`` script in their project, for bootstrapping the ``astropy_helpers`` package in their setup.py script. regions-0.4/astropy_helpers/CONTRIBUTING.md0000644000076600000240000000216513336766207020561 0ustar deilstaff00000000000000Contributing to astropy-helpers =============================== The guidelines for contributing to ``astropy-helpers`` are generally the same as the [contributing guidelines for the astropy core package](http://github.com/astropy/astropy/blob/master/CONTRIBUTING.md). Basically, report relevant issues in the ``astropy-helpers`` issue tracker, and we welcome pull requests that broadly follow the [Astropy coding guidelines](http://docs.astropy.org/en/latest/development/codeguide.html). The key subtlety lies in understanding the relationship between ``astropy`` and ``astropy-helpers``. This package contains the build, installation, and documentation tools used by astropy. It also includes support for the ``setup.py test`` command, though Astropy is still required for this to function (it does not currently include the full Astropy test runner). So issues or improvements to that functionality should be addressed in this package. Any other aspect of the [astropy core package](http://github.com/astropy/astropy) (or any other package that uses ``astropy-helpers``) should be addressed in the github repository for that package. regions-0.4/astropy_helpers/LICENSE.rst0000644000076600000240000000272313336766207020144 0ustar deilstaff00000000000000Copyright (c) 2014, Astropy Developers All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the Astropy Team nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. regions-0.4/astropy_helpers/MANIFEST.in0000644000076600000240000000025413467311012020044 0ustar deilstaff00000000000000include README.rst include CHANGES.rst include LICENSE.rst recursive-include licenses * include ah_bootstrap.py exclude *.pyc *.o prune build prune astropy_helpers/tests regions-0.4/astropy_helpers/README.rst0000644000076600000240000000503313336766207020014 0ustar deilstaff00000000000000astropy-helpers =============== * Stable versions: https://pypi.org/project/astropy-helpers/ * Development version, issue tracker: https://github.com/astropy/astropy-helpers This project provides a Python package, ``astropy_helpers``, which includes many build, installation, and documentation-related tools used by the Astropy project, but packaged separately for use by other projects that wish to leverage this work. The motivation behind this package and details of its implementation are in the accepted `Astropy Proposal for Enhancement (APE) 4 `_. The ``astropy_helpers.extern`` sub-module includes modules developed elsewhere that are bundled here for convenience. At the moment, this consists of the following two sphinx extensions: * `numpydoc `_, a Sphinx extension developed as part of the Numpy project. This is used to parse docstrings in Numpy format * `sphinx-automodapi `_, a Sphinx extension developed as part of the Astropy project. This used to be developed directly in ``astropy-helpers`` but is now a standalone package. Issues with these sub-modules should be reported in their respective repositories, and we will regularly update the bundled versions to reflect the latest released versions. ``astropy_helpers`` includes a special "bootstrap" module called ``ah_bootstrap.py`` which is intended to be used by a project's setup.py in order to ensure that the ``astropy_helpers`` package is available for build/installation. This is similar to the ``ez_setup.py`` module that is shipped with some projects to bootstrap `setuptools `_. As described in APE4, the version numbers for ``astropy_helpers`` follow the corresponding major/minor version of the `astropy core package `_, but with an independent sequence of micro (bugfix) version numbers. Hence, the initial release is 0.4, in parallel with Astropy v0.4, which will be the first version of Astropy to use ``astropy-helpers``. For examples of how to implement ``astropy-helpers`` in a project, see the ``setup.py`` and ``setup.cfg`` files of the `Affiliated package template `_. .. image:: https://travis-ci.org/astropy/astropy-helpers.svg :target: https://travis-ci.org/astropy/astropy-helpers .. image:: https://coveralls.io/repos/astropy/astropy-helpers/badge.svg :target: https://coveralls.io/r/astropy/astropy-helpers regions-0.4/astropy_helpers/ah_bootstrap.py0000644000076600000240000011116613477530461021366 0ustar deilstaff00000000000000""" This bootstrap module contains code for ensuring that the astropy_helpers package will be importable by the time the setup.py script runs. It also includes some workarounds to ensure that a recent-enough version of setuptools is being used for the installation. This module should be the first thing imported in the setup.py of distributions that make use of the utilities in astropy_helpers. If the distribution ships with its own copy of astropy_helpers, this module will first attempt to import from the shipped copy. However, it will also check PyPI to see if there are any bug-fix releases on top of the current version that may be useful to get past platform-specific bugs that have been fixed. When running setup.py, use the ``--offline`` command-line option to disable the auto-upgrade checks. When this module is imported or otherwise executed it automatically calls a main function that attempts to read the project's setup.cfg file, which it checks for a configuration section called ``[ah_bootstrap]`` the presences of that section, and options therein, determine the next step taken: If it contains an option called ``auto_use`` with a value of ``True``, it will automatically call the main function of this module called `use_astropy_helpers` (see that function's docstring for full details). Otherwise no further action is taken and by default the system-installed version of astropy-helpers will be used (however, ``ah_bootstrap.use_astropy_helpers`` may be called manually from within the setup.py script). This behavior can also be controlled using the ``--auto-use`` and ``--no-auto-use`` command-line flags. For clarity, an alias for ``--no-auto-use`` is ``--use-system-astropy-helpers``, and we recommend using the latter if needed. Additional options in the ``[ah_boostrap]`` section of setup.cfg have the same names as the arguments to `use_astropy_helpers`, and can be used to configure the bootstrap script when ``auto_use = True``. See https://github.com/astropy/astropy-helpers for more details, and for the latest version of this module. """ import contextlib import errno import io import locale import os import re import subprocess as sp import sys from distutils import log from distutils.debug import DEBUG try: from ConfigParser import ConfigParser, RawConfigParser except ImportError: from configparser import ConfigParser, RawConfigParser import pkg_resources from setuptools import Distribution from setuptools.package_index import PackageIndex # This is the minimum Python version required for astropy-helpers __minimum_python_version__ = (2, 7) if sys.version_info[0] < 3: _str_types = (str, unicode) _text_type = unicode PY3 = False else: _str_types = (str, bytes) _text_type = str PY3 = True # TODO: Maybe enable checking for a specific version of astropy_helpers? DIST_NAME = 'astropy-helpers' PACKAGE_NAME = 'astropy_helpers' if PY3: UPPER_VERSION_EXCLUSIVE = None else: UPPER_VERSION_EXCLUSIVE = '3' # Defaults for other options DOWNLOAD_IF_NEEDED = True INDEX_URL = 'https://pypi.python.org/simple' USE_GIT = True OFFLINE = False AUTO_UPGRADE = True # A list of all the configuration options and their required types CFG_OPTIONS = [ ('auto_use', bool), ('path', str), ('download_if_needed', bool), ('index_url', str), ('use_git', bool), ('offline', bool), ('auto_upgrade', bool) ] # Start off by parsing the setup.cfg file SETUP_CFG = ConfigParser() if os.path.exists('setup.cfg'): try: SETUP_CFG.read('setup.cfg') except Exception as e: if DEBUG: raise log.error( "Error reading setup.cfg: {0!r}\n{1} will not be " "automatically bootstrapped and package installation may fail." "\n{2}".format(e, PACKAGE_NAME, _err_help_msg)) # We used package_name in the package template for a while instead of name if SETUP_CFG.has_option('metadata', 'name'): parent_package = SETUP_CFG.get('metadata', 'name') elif SETUP_CFG.has_option('metadata', 'package_name'): parent_package = SETUP_CFG.get('metadata', 'package_name') else: parent_package = None if SETUP_CFG.has_option('options', 'python_requires'): python_requires = SETUP_CFG.get('options', 'python_requires') # The python_requires key has a syntax that can be parsed by SpecifierSet # in the packaging package. However, we don't want to have to depend on that # package, so instead we can use setuptools (which bundles packaging). We # have to add 'python' to parse it with Requirement. from pkg_resources import Requirement req = Requirement.parse('python' + python_requires) # We want the Python version as a string, which we can get from the platform module import platform # strip off trailing '+' incase this is a dev install of python python_version = platform.python_version().strip('+') # allow pre-releases to count as 'new enough' if not req.specifier.contains(python_version, True): if parent_package is None: print("ERROR: Python {} is required by this package".format(req.specifier)) else: print("ERROR: Python {} is required by {}".format(req.specifier, parent_package)) sys.exit(1) if sys.version_info < __minimum_python_version__: if parent_package is None: print("ERROR: Python {} or later is required by astropy-helpers".format( __minimum_python_version__)) else: print("ERROR: Python {} or later is required by astropy-helpers for {}".format( __minimum_python_version__, parent_package)) sys.exit(1) # What follows are several import statements meant to deal with install-time # issues with either missing or misbehaving pacakges (including making sure # setuptools itself is installed): # Check that setuptools 1.0 or later is present from distutils.version import LooseVersion try: import setuptools assert LooseVersion(setuptools.__version__) >= LooseVersion('1.0') except (ImportError, AssertionError): print("ERROR: setuptools 1.0 or later is required by astropy-helpers") sys.exit(1) # typing as a dependency for 1.6.1+ Sphinx causes issues when imported after # initializing submodule with ah_boostrap.py # See discussion and references in # https://github.com/astropy/astropy-helpers/issues/302 try: import typing # noqa except ImportError: pass # Note: The following import is required as a workaround to # https://github.com/astropy/astropy-helpers/issues/89; if we don't import this # module now, it will get cleaned up after `run_setup` is called, but that will # later cause the TemporaryDirectory class defined in it to stop working when # used later on by setuptools try: import setuptools.py31compat # noqa except ImportError: pass # matplotlib can cause problems if it is imported from within a call of # run_setup(), because in some circumstances it will try to write to the user's # home directory, resulting in a SandboxViolation. See # https://github.com/matplotlib/matplotlib/pull/4165 # Making sure matplotlib, if it is available, is imported early in the setup # process can mitigate this (note importing matplotlib.pyplot has the same # issue) try: import matplotlib matplotlib.use('Agg') import matplotlib.pyplot except: # Ignore if this fails for *any* reason* pass # End compatibility imports... class _Bootstrapper(object): """ Bootstrapper implementation. See ``use_astropy_helpers`` for parameter documentation. """ def __init__(self, path=None, index_url=None, use_git=None, offline=None, download_if_needed=None, auto_upgrade=None): if path is None: path = PACKAGE_NAME if not (isinstance(path, _str_types) or path is False): raise TypeError('path must be a string or False') if PY3 and not isinstance(path, _text_type): fs_encoding = sys.getfilesystemencoding() path = path.decode(fs_encoding) # path to unicode self.path = path # Set other option attributes, using defaults where necessary self.index_url = index_url if index_url is not None else INDEX_URL self.offline = offline if offline is not None else OFFLINE # If offline=True, override download and auto-upgrade if self.offline: download_if_needed = False auto_upgrade = False self.download = (download_if_needed if download_if_needed is not None else DOWNLOAD_IF_NEEDED) self.auto_upgrade = (auto_upgrade if auto_upgrade is not None else AUTO_UPGRADE) # If this is a release then the .git directory will not exist so we # should not use git. git_dir_exists = os.path.exists(os.path.join(os.path.dirname(__file__), '.git')) if use_git is None and not git_dir_exists: use_git = False self.use_git = use_git if use_git is not None else USE_GIT # Declared as False by default--later we check if astropy-helpers can be # upgraded from PyPI, but only if not using a source distribution (as in # the case of import from a git submodule) self.is_submodule = False @classmethod def main(cls, argv=None): if argv is None: argv = sys.argv config = cls.parse_config() config.update(cls.parse_command_line(argv)) auto_use = config.pop('auto_use', False) bootstrapper = cls(**config) if auto_use: # Run the bootstrapper, otherwise the setup.py is using the old # use_astropy_helpers() interface, in which case it will run the # bootstrapper manually after reconfiguring it. bootstrapper.run() return bootstrapper @classmethod def parse_config(cls): if not SETUP_CFG.has_section('ah_bootstrap'): return {} config = {} for option, type_ in CFG_OPTIONS: if not SETUP_CFG.has_option('ah_bootstrap', option): continue if type_ is bool: value = SETUP_CFG.getboolean('ah_bootstrap', option) else: value = SETUP_CFG.get('ah_bootstrap', option) config[option] = value return config @classmethod def parse_command_line(cls, argv=None): if argv is None: argv = sys.argv config = {} # For now we just pop recognized ah_bootstrap options out of the # arg list. This is imperfect; in the unlikely case that a setup.py # custom command or even custom Distribution class defines an argument # of the same name then we will break that. However there's a catch22 # here that we can't just do full argument parsing right here, because # we don't yet know *how* to parse all possible command-line arguments. if '--no-git' in argv: config['use_git'] = False argv.remove('--no-git') if '--offline' in argv: config['offline'] = True argv.remove('--offline') if '--auto-use' in argv: config['auto_use'] = True argv.remove('--auto-use') if '--no-auto-use' in argv: config['auto_use'] = False argv.remove('--no-auto-use') if '--use-system-astropy-helpers' in argv: config['auto_use'] = False argv.remove('--use-system-astropy-helpers') return config def run(self): strategies = ['local_directory', 'local_file', 'index'] dist = None # First, remove any previously imported versions of astropy_helpers; # this is necessary for nested installs where one package's installer # is installing another package via setuptools.sandbox.run_setup, as in # the case of setup_requires for key in list(sys.modules): try: if key == PACKAGE_NAME or key.startswith(PACKAGE_NAME + '.'): del sys.modules[key] except AttributeError: # Sometimes mysterious non-string things can turn up in # sys.modules continue # Check to see if the path is a submodule self.is_submodule = self._check_submodule() for strategy in strategies: method = getattr(self, 'get_{0}_dist'.format(strategy)) dist = method() if dist is not None: break else: raise _AHBootstrapSystemExit( "No source found for the {0!r} package; {0} must be " "available and importable as a prerequisite to building " "or installing this package.".format(PACKAGE_NAME)) # This is a bit hacky, but if astropy_helpers was loaded from a # directory/submodule its Distribution object gets a "precedence" of # "DEVELOP_DIST". However, in other cases it gets a precedence of # "EGG_DIST". However, when activing the distribution it will only be # placed early on sys.path if it is treated as an EGG_DIST, so always # do that dist = dist.clone(precedence=pkg_resources.EGG_DIST) # Otherwise we found a version of astropy-helpers, so we're done # Just active the found distribution on sys.path--if we did a # download this usually happens automatically but it doesn't hurt to # do it again # Note: Adding the dist to the global working set also activates it # (makes it importable on sys.path) by default. try: pkg_resources.working_set.add(dist, replace=True) except TypeError: # Some (much) older versions of setuptools do not have the # replace=True option here. These versions are old enough that all # bets may be off anyways, but it's easy enough to work around just # in case... if dist.key in pkg_resources.working_set.by_key: del pkg_resources.working_set.by_key[dist.key] pkg_resources.working_set.add(dist) @property def config(self): """ A `dict` containing the options this `_Bootstrapper` was configured with. """ return dict((optname, getattr(self, optname)) for optname, _ in CFG_OPTIONS if hasattr(self, optname)) def get_local_directory_dist(self): """ Handle importing a vendored package from a subdirectory of the source distribution. """ if not os.path.isdir(self.path): return log.info('Attempting to import astropy_helpers from {0} {1!r}'.format( 'submodule' if self.is_submodule else 'directory', self.path)) dist = self._directory_import() if dist is None: log.warn( 'The requested path {0!r} for importing {1} does not ' 'exist, or does not contain a copy of the {1} ' 'package.'.format(self.path, PACKAGE_NAME)) elif self.auto_upgrade and not self.is_submodule: # A version of astropy-helpers was found on the available path, but # check to see if a bugfix release is available on PyPI upgrade = self._do_upgrade(dist) if upgrade is not None: dist = upgrade return dist def get_local_file_dist(self): """ Handle importing from a source archive; this also uses setup_requires but points easy_install directly to the source archive. """ if not os.path.isfile(self.path): return log.info('Attempting to unpack and import astropy_helpers from ' '{0!r}'.format(self.path)) try: dist = self._do_download(find_links=[self.path]) except Exception as e: if DEBUG: raise log.warn( 'Failed to import {0} from the specified archive {1!r}: ' '{2}'.format(PACKAGE_NAME, self.path, str(e))) dist = None if dist is not None and self.auto_upgrade: # A version of astropy-helpers was found on the available path, but # check to see if a bugfix release is available on PyPI upgrade = self._do_upgrade(dist) if upgrade is not None: dist = upgrade return dist def get_index_dist(self): if not self.download: log.warn('Downloading {0!r} disabled.'.format(DIST_NAME)) return None log.warn( "Downloading {0!r}; run setup.py with the --offline option to " "force offline installation.".format(DIST_NAME)) try: dist = self._do_download() except Exception as e: if DEBUG: raise log.warn( 'Failed to download and/or install {0!r} from {1!r}:\n' '{2}'.format(DIST_NAME, self.index_url, str(e))) dist = None # No need to run auto-upgrade here since we've already presumably # gotten the most up-to-date version from the package index return dist def _directory_import(self): """ Import astropy_helpers from the given path, which will be added to sys.path. Must return True if the import succeeded, and False otherwise. """ # Return True on success, False on failure but download is allowed, and # otherwise raise SystemExit path = os.path.abspath(self.path) # Use an empty WorkingSet rather than the man # pkg_resources.working_set, since on older versions of setuptools this # will invoke a VersionConflict when trying to install an upgrade ws = pkg_resources.WorkingSet([]) ws.add_entry(path) dist = ws.by_key.get(DIST_NAME) if dist is None: # We didn't find an egg-info/dist-info in the given path, but if a # setup.py exists we can generate it setup_py = os.path.join(path, 'setup.py') if os.path.isfile(setup_py): # We use subprocess instead of run_setup from setuptools to # avoid segmentation faults - see the following for more details: # https://github.com/cython/cython/issues/2104 sp.check_output([sys.executable, 'setup.py', 'egg_info'], cwd=path) for dist in pkg_resources.find_distributions(path, True): # There should be only one... return dist return dist def _do_download(self, version='', find_links=None): if find_links: allow_hosts = '' index_url = None else: allow_hosts = None index_url = self.index_url # Annoyingly, setuptools will not handle other arguments to # Distribution (such as options) before handling setup_requires, so it # is not straightforward to programmatically augment the arguments which # are passed to easy_install class _Distribution(Distribution): def get_option_dict(self, command_name): opts = Distribution.get_option_dict(self, command_name) if command_name == 'easy_install': if find_links is not None: opts['find_links'] = ('setup script', find_links) if index_url is not None: opts['index_url'] = ('setup script', index_url) if allow_hosts is not None: opts['allow_hosts'] = ('setup script', allow_hosts) return opts if version: req = '{0}=={1}'.format(DIST_NAME, version) else: if UPPER_VERSION_EXCLUSIVE is None: req = DIST_NAME else: req = '{0}<{1}'.format(DIST_NAME, UPPER_VERSION_EXCLUSIVE) attrs = {'setup_requires': [req]} # NOTE: we need to parse the config file (e.g. setup.cfg) to make sure # it honours the options set in the [easy_install] section, and we need # to explicitly fetch the requirement eggs as setup_requires does not # get honored in recent versions of setuptools: # https://github.com/pypa/setuptools/issues/1273 try: context = _verbose if DEBUG else _silence with context(): dist = _Distribution(attrs=attrs) try: dist.parse_config_files(ignore_option_errors=True) dist.fetch_build_eggs(req) except TypeError: # On older versions of setuptools, ignore_option_errors # doesn't exist, and the above two lines are not needed # so we can just continue pass # If the setup_requires succeeded it will have added the new dist to # the main working_set return pkg_resources.working_set.by_key.get(DIST_NAME) except Exception as e: if DEBUG: raise msg = 'Error retrieving {0} from {1}:\n{2}' if find_links: source = find_links[0] elif index_url != INDEX_URL: source = index_url else: source = 'PyPI' raise Exception(msg.format(DIST_NAME, source, repr(e))) def _do_upgrade(self, dist): # Build up a requirement for a higher bugfix release but a lower minor # release (so API compatibility is guaranteed) next_version = _next_version(dist.parsed_version) req = pkg_resources.Requirement.parse( '{0}>{1},<{2}'.format(DIST_NAME, dist.version, next_version)) package_index = PackageIndex(index_url=self.index_url) upgrade = package_index.obtain(req) if upgrade is not None: return self._do_download(version=upgrade.version) def _check_submodule(self): """ Check if the given path is a git submodule. See the docstrings for ``_check_submodule_using_git`` and ``_check_submodule_no_git`` for further details. """ if (self.path is None or (os.path.exists(self.path) and not os.path.isdir(self.path))): return False if self.use_git: return self._check_submodule_using_git() else: return self._check_submodule_no_git() def _check_submodule_using_git(self): """ Check if the given path is a git submodule. If so, attempt to initialize and/or update the submodule if needed. This function makes calls to the ``git`` command in subprocesses. The ``_check_submodule_no_git`` option uses pure Python to check if the given path looks like a git submodule, but it cannot perform updates. """ cmd = ['git', 'submodule', 'status', '--', self.path] try: log.info('Running `{0}`; use the --no-git option to disable git ' 'commands'.format(' '.join(cmd))) returncode, stdout, stderr = run_cmd(cmd) except _CommandNotFound: # The git command simply wasn't found; this is most likely the # case on user systems that don't have git and are simply # trying to install the package from PyPI or a source # distribution. Silently ignore this case and simply don't try # to use submodules return False stderr = stderr.strip() if returncode != 0 and stderr: # Unfortunately the return code alone cannot be relied on, as # earlier versions of git returned 0 even if the requested submodule # does not exist # This is a warning that occurs in perl (from running git submodule) # which only occurs with a malformatted locale setting which can # happen sometimes on OSX. See again # https://github.com/astropy/astropy/issues/2749 perl_warning = ('perl: warning: Falling back to the standard locale ' '("C").') if not stderr.strip().endswith(perl_warning): # Some other unknown error condition occurred log.warn('git submodule command failed ' 'unexpectedly:\n{0}'.format(stderr)) return False # Output of `git submodule status` is as follows: # # 1: Status indicator: '-' for submodule is uninitialized, '+' if # submodule is initialized but is not at the commit currently indicated # in .gitmodules (and thus needs to be updated), or 'U' if the # submodule is in an unstable state (i.e. has merge conflicts) # # 2. SHA-1 hash of the current commit of the submodule (we don't really # need this information but it's useful for checking that the output is # correct) # # 3. The output of `git describe` for the submodule's current commit # hash (this includes for example what branches the commit is on) but # only if the submodule is initialized. We ignore this information for # now _git_submodule_status_re = re.compile( r'^(?P[+-U ])(?P[0-9a-f]{40}) ' r'(?P\S+)( .*)?$') # The stdout should only contain one line--the status of the # requested submodule m = _git_submodule_status_re.match(stdout) if m: # Yes, the path *is* a git submodule self._update_submodule(m.group('submodule'), m.group('status')) return True else: log.warn( 'Unexpected output from `git submodule status`:\n{0}\n' 'Will attempt import from {1!r} regardless.'.format( stdout, self.path)) return False def _check_submodule_no_git(self): """ Like ``_check_submodule_using_git``, but simply parses the .gitmodules file to determine if the supplied path is a git submodule, and does not exec any subprocesses. This can only determine if a path is a submodule--it does not perform updates, etc. This function may need to be updated if the format of the .gitmodules file is changed between git versions. """ gitmodules_path = os.path.abspath('.gitmodules') if not os.path.isfile(gitmodules_path): return False # This is a minimal reader for gitconfig-style files. It handles a few of # the quirks that make gitconfig files incompatible with ConfigParser-style # files, but does not support the full gitconfig syntax (just enough # needed to read a .gitmodules file). gitmodules_fileobj = io.StringIO() # Must use io.open for cross-Python-compatible behavior wrt unicode with io.open(gitmodules_path) as f: for line in f: # gitconfig files are more flexible with leading whitespace; just # go ahead and remove it line = line.lstrip() # comments can start with either # or ; if line and line[0] in (':', ';'): continue gitmodules_fileobj.write(line) gitmodules_fileobj.seek(0) cfg = RawConfigParser() try: cfg.readfp(gitmodules_fileobj) except Exception as exc: log.warn('Malformatted .gitmodules file: {0}\n' '{1} cannot be assumed to be a git submodule.'.format( exc, self.path)) return False for section in cfg.sections(): if not cfg.has_option(section, 'path'): continue submodule_path = cfg.get(section, 'path').rstrip(os.sep) if submodule_path == self.path.rstrip(os.sep): return True return False def _update_submodule(self, submodule, status): if status == ' ': # The submodule is up to date; no action necessary return elif status == '-': if self.offline: raise _AHBootstrapSystemExit( "Cannot initialize the {0} submodule in --offline mode; " "this requires being able to clone the submodule from an " "online repository.".format(submodule)) cmd = ['update', '--init'] action = 'Initializing' elif status == '+': cmd = ['update'] action = 'Updating' if self.offline: cmd.append('--no-fetch') elif status == 'U': raise _AHBootstrapSystemExit( 'Error: Submodule {0} contains unresolved merge conflicts. ' 'Please complete or abandon any changes in the submodule so that ' 'it is in a usable state, then try again.'.format(submodule)) else: log.warn('Unknown status {0!r} for git submodule {1!r}. Will ' 'attempt to use the submodule as-is, but try to ensure ' 'that the submodule is in a clean state and contains no ' 'conflicts or errors.\n{2}'.format(status, submodule, _err_help_msg)) return err_msg = None cmd = ['git', 'submodule'] + cmd + ['--', submodule] log.warn('{0} {1} submodule with: `{2}`'.format( action, submodule, ' '.join(cmd))) try: log.info('Running `{0}`; use the --no-git option to disable git ' 'commands'.format(' '.join(cmd))) returncode, stdout, stderr = run_cmd(cmd) except OSError as e: err_msg = str(e) else: if returncode != 0: err_msg = stderr if err_msg is not None: log.warn('An unexpected error occurred updating the git submodule ' '{0!r}:\n{1}\n{2}'.format(submodule, err_msg, _err_help_msg)) class _CommandNotFound(OSError): """ An exception raised when a command run with run_cmd is not found on the system. """ def run_cmd(cmd): """ Run a command in a subprocess, given as a list of command-line arguments. Returns a ``(returncode, stdout, stderr)`` tuple. """ try: p = sp.Popen(cmd, stdout=sp.PIPE, stderr=sp.PIPE) # XXX: May block if either stdout or stderr fill their buffers; # however for the commands this is currently used for that is # unlikely (they should have very brief output) stdout, stderr = p.communicate() except OSError as e: if DEBUG: raise if e.errno == errno.ENOENT: msg = 'Command not found: `{0}`'.format(' '.join(cmd)) raise _CommandNotFound(msg, cmd) else: raise _AHBootstrapSystemExit( 'An unexpected error occurred when running the ' '`{0}` command:\n{1}'.format(' '.join(cmd), str(e))) # Can fail of the default locale is not configured properly. See # https://github.com/astropy/astropy/issues/2749. For the purposes under # consideration 'latin1' is an acceptable fallback. try: stdio_encoding = locale.getdefaultlocale()[1] or 'latin1' except ValueError: # Due to an OSX oddity locale.getdefaultlocale() can also crash # depending on the user's locale/language settings. See: # http://bugs.python.org/issue18378 stdio_encoding = 'latin1' # Unlikely to fail at this point but even then let's be flexible if not isinstance(stdout, _text_type): stdout = stdout.decode(stdio_encoding, 'replace') if not isinstance(stderr, _text_type): stderr = stderr.decode(stdio_encoding, 'replace') return (p.returncode, stdout, stderr) def _next_version(version): """ Given a parsed version from pkg_resources.parse_version, returns a new version string with the next minor version. Examples ======== >>> _next_version(pkg_resources.parse_version('1.2.3')) '1.3.0' """ if hasattr(version, 'base_version'): # New version parsing from setuptools >= 8.0 if version.base_version: parts = version.base_version.split('.') else: parts = [] else: parts = [] for part in version: if part.startswith('*'): break parts.append(part) parts = [int(p) for p in parts] if len(parts) < 3: parts += [0] * (3 - len(parts)) major, minor, micro = parts[:3] return '{0}.{1}.{2}'.format(major, minor + 1, 0) class _DummyFile(object): """A noop writeable object.""" errors = '' # Required for Python 3.x encoding = 'utf-8' def write(self, s): pass def flush(self): pass @contextlib.contextmanager def _verbose(): yield @contextlib.contextmanager def _silence(): """A context manager that silences sys.stdout and sys.stderr.""" old_stdout = sys.stdout old_stderr = sys.stderr sys.stdout = _DummyFile() sys.stderr = _DummyFile() exception_occurred = False try: yield except: exception_occurred = True # Go ahead and clean up so that exception handling can work normally sys.stdout = old_stdout sys.stderr = old_stderr raise if not exception_occurred: sys.stdout = old_stdout sys.stderr = old_stderr _err_help_msg = """ If the problem persists consider installing astropy_helpers manually using pip (`pip install astropy_helpers`) or by manually downloading the source archive, extracting it, and installing by running `python setup.py install` from the root of the extracted source code. """ class _AHBootstrapSystemExit(SystemExit): def __init__(self, *args): if not args: msg = 'An unknown problem occurred bootstrapping astropy_helpers.' else: msg = args[0] msg += '\n' + _err_help_msg super(_AHBootstrapSystemExit, self).__init__(msg, *args[1:]) BOOTSTRAPPER = _Bootstrapper.main() def use_astropy_helpers(**kwargs): """ Ensure that the `astropy_helpers` module is available and is importable. This supports automatic submodule initialization if astropy_helpers is included in a project as a git submodule, or will download it from PyPI if necessary. Parameters ---------- path : str or None, optional A filesystem path relative to the root of the project's source code that should be added to `sys.path` so that `astropy_helpers` can be imported from that path. If the path is a git submodule it will automatically be initialized and/or updated. The path may also be to a ``.tar.gz`` archive of the astropy_helpers source distribution. In this case the archive is automatically unpacked and made temporarily available on `sys.path` as a ``.egg`` archive. If `None` skip straight to downloading. download_if_needed : bool, optional If the provided filesystem path is not found an attempt will be made to download astropy_helpers from PyPI. It will then be made temporarily available on `sys.path` as a ``.egg`` archive (using the ``setup_requires`` feature of setuptools. If the ``--offline`` option is given at the command line the value of this argument is overridden to `False`. index_url : str, optional If provided, use a different URL for the Python package index than the main PyPI server. use_git : bool, optional If `False` no git commands will be used--this effectively disables support for git submodules. If the ``--no-git`` option is given at the command line the value of this argument is overridden to `False`. auto_upgrade : bool, optional By default, when installing a package from a non-development source distribution ah_boostrap will try to automatically check for patch releases to astropy-helpers on PyPI and use the patched version over any bundled versions. Setting this to `False` will disable that functionality. If the ``--offline`` option is given at the command line the value of this argument is overridden to `False`. offline : bool, optional If `False` disable all actions that require an internet connection, including downloading packages from the package index and fetching updates to any git submodule. Defaults to `True`. """ global BOOTSTRAPPER config = BOOTSTRAPPER.config config.update(**kwargs) # Create a new bootstrapper with the updated configuration and run it BOOTSTRAPPER = _Bootstrapper(**config) BOOTSTRAPPER.run() regions-0.4/astropy_helpers/appveyor.yml0000644000076600000240000000266013467311012020701 0ustar deilstaff00000000000000# AppVeyor.com is a Continuous Integration service to build and run tests under # Windows environment: global: PYTHON: "C:\\conda" MINICONDA_VERSION: "latest" CMD_IN_ENV: "cmd /E:ON /V:ON /C .\\ci-helpers\\appveyor\\windows_sdk.cmd" PYTHON_ARCH: "64" # needs to be set for CMD_IN_ENV to succeed. If a mix # of 32 bit and 64 bit builds are needed, move this # to the matrix section. # babel 2.0 is known to break on Windows: # https://github.com/python-babel/babel/issues/174 CONDA_DEPENDENCIES: "numpy Cython sphinx pytest babel!=2.0 setuptools" matrix: - PYTHON_VERSION: "2.7" - PYTHON_VERSION: "3.4" - PYTHON_VERSION: "3.5" - PYTHON_VERSION: "3.6" - PYTHON_VERSION: "3.7" matrix: fast_finish: true allow_failures: - PYTHON_VERSION: "2.7" platform: -x64 install: # Set up ci-helpers - "git clone git://github.com/astropy/ci-helpers.git" - "powershell ci-helpers/appveyor/install-miniconda.ps1" - "SET PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%" - "activate test" # Some of the tests use git commands that require a user to be configured - git config --global user.name "A U Thor" - git config --global user.email "author@example.com" # Not a .NET project, we build the package in the install step instead build: false test_script: - "%CMD_IN_ENV% py.test astropy_helpers" regions-0.4/astropy_helpers/astropy_helpers/0000755000076600000240000000000013501657425021542 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/__init__.py0000644000076600000240000000345413336766207023666 0ustar deilstaff00000000000000try: from .version import version as __version__ from .version import githash as __githash__ except ImportError: __version__ = '' __githash__ = '' # If we've made it as far as importing astropy_helpers, we don't need # ah_bootstrap in sys.modules anymore. Getting rid of it is actually necessary # if the package we're installing has a setup_requires of another package that # uses astropy_helpers (and possibly a different version at that) # See https://github.com/astropy/astropy/issues/3541 import sys if 'ah_bootstrap' in sys.modules: del sys.modules['ah_bootstrap'] # Note, this is repeated from ah_bootstrap.py, but is here too in case this # astropy-helpers was upgraded to from an older version that did not have this # check in its ah_bootstrap. # matplotlib can cause problems if it is imported from within a call of # run_setup(), because in some circumstances it will try to write to the user's # home directory, resulting in a SandboxViolation. See # https://github.com/matplotlib/matplotlib/pull/4165 # Making sure matplotlib, if it is available, is imported early in the setup # process can mitigate this (note importing matplotlib.pyplot has the same # issue) try: import matplotlib matplotlib.use('Agg') import matplotlib.pyplot except: # Ignore if this fails for *any* reason* pass import os # Ensure that all module-level code in astropy or other packages know that # we're in setup mode: if ('__main__' in sys.modules and hasattr(sys.modules['__main__'], '__file__')): filename = os.path.basename(sys.modules['__main__'].__file__) if filename.rstrip('co') == 'setup.py': if sys.version_info[0] >= 3: import builtins else: import __builtin__ as builtins builtins._ASTROPY_SETUP_ = True del filename regions-0.4/astropy_helpers/astropy_helpers/commands/0000755000076600000240000000000013501657425023343 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/commands/__init__.py0000644000076600000240000000000013336766207025447 0ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/commands/_dummy.py0000644000076600000240000000557413336766207025227 0ustar deilstaff00000000000000""" Provides a base class for a 'dummy' setup.py command that has no functionality (probably due to a missing requirement). This dummy command can raise an exception when it is run, explaining to the user what dependencies must be met to use this command. The reason this is at all tricky is that we want the command to be able to provide this message even when the user passes arguments to the command. If we don't know ahead of time what arguments the command can take, this is difficult, because distutils does not allow unknown arguments to be passed to a setup.py command. This hacks around that restriction to provide a useful error message even when a user passes arguments to the dummy implementation of a command. Use this like: try: from some_dependency import SetupCommand except ImportError: from ._dummy import _DummyCommand class SetupCommand(_DummyCommand): description = \ 'Implementation of SetupCommand from some_dependency; ' 'some_dependency must be installed to run this command' # This is the message that will be raised when a user tries to # run this command--define it as a class attribute. error_msg = \ "The 'setup_command' command requires the some_dependency " "package to be installed and importable." """ import sys from setuptools import Command from distutils.errors import DistutilsArgError from textwrap import dedent class _DummyCommandMeta(type): """ Causes an exception to be raised on accessing attributes of a command class so that if ``./setup.py command_name`` is run with additional command-line options we can provide a useful error message instead of the default that tells users the options are unrecognized. """ def __init__(cls, name, bases, members): if bases == (Command, object): # This is the _DummyCommand base class, presumably return if not hasattr(cls, 'description'): raise TypeError( "_DummyCommand subclass must have a 'description' " "attribute.") if not hasattr(cls, 'error_msg'): raise TypeError( "_DummyCommand subclass must have an 'error_msg' " "attribute.") def __getattribute__(cls, attr): if attr in ('description', 'error_msg'): # Allow cls.description to work so that `./setup.py # --help-commands` still works return super(_DummyCommandMeta, cls).__getattribute__(attr) raise DistutilsArgError(cls.error_msg) if sys.version_info[0] < 3: exec(dedent(""" class _DummyCommand(Command, object): __metaclass__ = _DummyCommandMeta """)) else: exec(dedent(""" class _DummyCommand(Command, object, metaclass=_DummyCommandMeta): pass """)) regions-0.4/astropy_helpers/astropy_helpers/commands/_test_compat.py0000644000076600000240000002671213336766207026413 0ustar deilstaff00000000000000""" Old implementation of ``./setup.py test`` command. This has been moved to astropy.tests as of Astropy v1.1.0, but a copy of the implementation is kept here for backwards compatibility. """ from __future__ import absolute_import, unicode_literals import inspect import os import shutil import subprocess import sys import tempfile from setuptools import Command from ..compat import _fix_user_options PY3 = sys.version_info[0] == 3 class AstropyTest(Command, object): description = 'Run the tests for this package' user_options = [ ('package=', 'P', "The name of a specific package to test, e.g. 'io.fits' or 'utils'. " "If nothing is specified, all default tests are run."), ('test-path=', 't', 'Specify a test location by path. If a relative path to a .py file, ' 'it is relative to the built package, so e.g., a leading "astropy/" ' 'is necessary. If a relative path to a .rst file, it is relative to ' 'the directory *below* the --docs-path directory, so a leading ' '"docs/" is usually necessary. May also be an absolute path.'), ('verbose-results', 'V', 'Turn on verbose output from pytest.'), ('plugins=', 'p', 'Plugins to enable when running pytest.'), ('pastebin=', 'b', "Enable pytest pastebin output. Either 'all' or 'failed'."), ('args=', 'a', 'Additional arguments to be passed to pytest.'), ('remote-data', 'R', 'Run tests that download remote data.'), ('pep8', '8', 'Enable PEP8 checking and disable regular tests. ' 'Requires the pytest-pep8 plugin.'), ('pdb', 'd', 'Start the interactive Python debugger on errors.'), ('coverage', 'c', 'Create a coverage report. Requires the coverage package.'), ('open-files', 'o', 'Fail if any tests leave files open. Requires the ' 'psutil package.'), ('parallel=', 'j', 'Run the tests in parallel on the specified number of ' 'CPUs. If negative, all the cores on the machine will be ' 'used. Requires the pytest-xdist plugin.'), ('docs-path=', None, 'The path to the documentation .rst files. If not provided, and ' 'the current directory contains a directory called "docs", that ' 'will be used.'), ('skip-docs', None, "Don't test the documentation .rst files."), ('repeat=', None, 'How many times to repeat each test (can be used to check for ' 'sporadic failures).'), ('temp-root=', None, 'The root directory in which to create the temporary testing files. ' 'If unspecified the system default is used (e.g. /tmp) as explained ' 'in the documentation for tempfile.mkstemp.') ] user_options = _fix_user_options(user_options) package_name = '' def initialize_options(self): self.package = None self.test_path = None self.verbose_results = False self.plugins = None self.pastebin = None self.args = None self.remote_data = False self.pep8 = False self.pdb = False self.coverage = False self.open_files = False self.parallel = 0 self.docs_path = None self.skip_docs = False self.repeat = None self.temp_root = None def finalize_options(self): # Normally we would validate the options here, but that's handled in # run_tests pass # Most of the test runner arguments have the same name as attributes on # this command class, with one exception (for now) _test_runner_arg_attr_map = { 'verbose': 'verbose_results' } def generate_testing_command(self): """ Build a Python script to run the tests. """ cmd_pre = '' # Commands to run before the test function cmd_post = '' # Commands to run after the test function if self.coverage: pre, post = self._generate_coverage_commands() cmd_pre += pre cmd_post += post def get_attr(arg): attr = self._test_runner_arg_attr_map.get(arg, arg) return getattr(self, attr) test_args = filter(lambda arg: hasattr(self, arg), self._get_test_runner_args()) test_args = ', '.join('{0}={1!r}'.format(arg, get_attr(arg)) for arg in test_args) if PY3: set_flag = "import builtins; builtins._ASTROPY_TEST_ = True" else: set_flag = "import __builtin__; __builtin__._ASTROPY_TEST_ = True" cmd = ('{cmd_pre}{0}; import {1.package_name}, sys; result = ' '{1.package_name}.test({test_args}); {cmd_post}' 'sys.exit(result)') return cmd.format(set_flag, self, cmd_pre=cmd_pre, cmd_post=cmd_post, test_args=test_args) def _validate_required_deps(self): """ This method checks that any required modules are installed before running the tests. """ try: import astropy # noqa except ImportError: raise ImportError( "The 'test' command requires the astropy package to be " "installed and importable.") def run(self): """ Run the tests! """ # Ensure there is a doc path if self.docs_path is None: if os.path.exists('docs'): self.docs_path = os.path.abspath('docs') # Build a testing install of the package self._build_temp_install() # Ensure all required packages are installed self._validate_required_deps() # Run everything in a try: finally: so that the tmp dir gets deleted. try: # Construct this modules testing command cmd = self.generate_testing_command() # Run the tests in a subprocess--this is necessary since # new extension modules may have appeared, and this is the # easiest way to set up a new environment # On Python 3.x prior to 3.3, the creation of .pyc files # is not atomic. py.test jumps through some hoops to make # this work by parsing import statements and carefully # importing files atomically. However, it can't detect # when __import__ is used, so its carefulness still fails. # The solution here (admittedly a bit of a hack), is to # turn off the generation of .pyc files altogether by # passing the `-B` switch to `python`. This does mean # that each core will have to compile .py file to bytecode # itself, rather than getting lucky and borrowing the work # already done by another core. Compilation is an # insignificant fraction of total testing time, though, so # it's probably not worth worrying about. retcode = subprocess.call([sys.executable, '-B', '-c', cmd], cwd=self.testing_path, close_fds=False) finally: # Remove temporary directory shutil.rmtree(self.tmp_dir) raise SystemExit(retcode) def _build_temp_install(self): """ Build the package and copy the build to a temporary directory for the purposes of testing this avoids creating pyc and __pycache__ directories inside the build directory """ self.reinitialize_command('build', inplace=True) self.run_command('build') build_cmd = self.get_finalized_command('build') new_path = os.path.abspath(build_cmd.build_lib) # On OSX the default path for temp files is under /var, but in most # cases on OSX /var is actually a symlink to /private/var; ensure we # dereference that link, because py.test is very sensitive to relative # paths... tmp_dir = tempfile.mkdtemp(prefix=self.package_name + '-test-', dir=self.temp_root) self.tmp_dir = os.path.realpath(tmp_dir) self.testing_path = os.path.join(self.tmp_dir, os.path.basename(new_path)) shutil.copytree(new_path, self.testing_path) new_docs_path = os.path.join(self.tmp_dir, os.path.basename(self.docs_path)) shutil.copytree(self.docs_path, new_docs_path) self.docs_path = new_docs_path shutil.copy('setup.cfg', self.tmp_dir) def _generate_coverage_commands(self): """ This method creates the post and pre commands if coverage is to be generated """ if self.parallel != 0: raise ValueError( "--coverage can not be used with --parallel") try: import coverage # noqa except ImportError: raise ImportError( "--coverage requires that the coverage package is " "installed.") # Don't use get_pkg_data_filename here, because it # requires importing astropy.config and thus screwing # up coverage results for those packages. coveragerc = os.path.join( self.testing_path, self.package_name, 'tests', 'coveragerc') # We create a coveragerc that is specific to the version # of Python we're running, so that we can mark branches # as being specifically for Python 2 or Python 3 with open(coveragerc, 'r') as fd: coveragerc_content = fd.read() if PY3: ignore_python_version = '2' else: ignore_python_version = '3' coveragerc_content = coveragerc_content.replace( "{ignore_python_version}", ignore_python_version).replace( "{packagename}", self.package_name) tmp_coveragerc = os.path.join(self.tmp_dir, 'coveragerc') with open(tmp_coveragerc, 'wb') as tmp: tmp.write(coveragerc_content.encode('utf-8')) cmd_pre = ( 'import coverage; ' 'cov = coverage.coverage(data_file="{0}", config_file="{1}"); ' 'cov.start();'.format( os.path.abspath(".coverage"), tmp_coveragerc)) cmd_post = ( 'cov.stop(); ' 'from astropy.tests.helper import _save_coverage; ' '_save_coverage(cov, result, "{0}", "{1}");'.format( os.path.abspath('.'), self.testing_path)) return cmd_pre, cmd_post def _get_test_runner_args(self): """ A hack to determine what arguments are supported by the package's test() function. In the future there should be a more straightforward API to determine this (really it should be determined by the ``TestRunner`` class for whatever version of Astropy is in use). """ if PY3: import builtins builtins._ASTROPY_TEST_ = True else: import __builtin__ __builtin__._ASTROPY_TEST_ = True try: pkg = __import__(self.package_name) if not hasattr(pkg, 'test'): raise ImportError( 'package {0} does not have a {0}.test() function as ' 'required by the Astropy test runner'.format(self.package_name)) argspec = inspect.getargspec(pkg.test) return argspec.args finally: if PY3: del builtins._ASTROPY_TEST_ else: del __builtin__._ASTROPY_TEST_ regions-0.4/astropy_helpers/astropy_helpers/commands/build_ext.py0000644000076600000240000004651113467311012025671 0ustar deilstaff00000000000000import errno import os import re import shlex import shutil import subprocess import sys import textwrap from distutils import log, ccompiler, sysconfig from distutils.core import Extension from distutils.ccompiler import get_default_compiler from setuptools.command.build_ext import build_ext as SetuptoolsBuildExt from ..utils import get_numpy_include_path, invalidate_caches, classproperty from ..version_helpers import get_pkg_version_module def should_build_with_cython(package, release=None): """Returns the previously used Cython version (or 'unknown' if not previously built) if Cython should be used to build extension modules from pyx files. If the ``release`` parameter is not specified an attempt is made to determine the release flag from `astropy.version`. """ try: version_module = __import__(package + '.cython_version', fromlist=['release', 'cython_version']) except ImportError: version_module = None if release is None and version_module is not None: try: release = version_module.release except AttributeError: pass try: cython_version = version_module.cython_version except AttributeError: cython_version = 'unknown' # Only build with Cython if, of course, Cython is installed, we're in a # development version (i.e. not release) or the Cython-generated source # files haven't been created yet (cython_version == 'unknown'). The latter # case can happen even when release is True if checking out a release tag # from the repository have_cython = False try: import Cython # noqa have_cython = True except ImportError: pass if have_cython and (not release or cython_version == 'unknown'): return cython_version else: return False _compiler_versions = {} def get_compiler_version(compiler): if compiler in _compiler_versions: return _compiler_versions[compiler] # Different flags to try to get the compiler version # TODO: It might be worth making this configurable to support # arbitrary odd compilers; though all bets may be off in such # cases anyway flags = ['--version', '--Version', '-version', '-Version', '-v', '-V'] def try_get_version(flag): process = subprocess.Popen( shlex.split(compiler, posix=('win' not in sys.platform)) + [flag], stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = process.communicate() if process.returncode != 0: return 'unknown' output = stdout.strip().decode('latin-1') # Safest bet if not output: # Some compilers return their version info on stderr output = stderr.strip().decode('latin-1') if not output: output = 'unknown' return output for flag in flags: version = try_get_version(flag) if version != 'unknown': break # Cache results to speed up future calls _compiler_versions[compiler] = version return version # TODO: I think this can be reworked without having to create the class # programmatically. def generate_build_ext_command(packagename, release): """ Creates a custom 'build_ext' command that allows for manipulating some of the C extension options at build time. We use a function to build the class since the base class for build_ext may be different depending on certain build-time parameters (for example, we may use Cython's build_ext instead of the default version in distutils). Uses the default distutils.command.build_ext by default. """ class build_ext(SetuptoolsBuildExt, object): package_name = packagename is_release = release _user_options = SetuptoolsBuildExt.user_options[:] _boolean_options = SetuptoolsBuildExt.boolean_options[:] _help_options = SetuptoolsBuildExt.help_options[:] force_rebuild = False _broken_compiler_mapping = [ ('i686-apple-darwin[0-9]*-llvm-gcc-4.2', 'clang') ] # Warning: Spaghetti code ahead. # During setup.py, the setup_helpers module needs the ability to add # items to a command's user_options list. At this stage we don't know # whether or not we can build with Cython, and so don't know for sure # what base class will be used for build_ext; nevertheless we want to # be able to provide a list to add options into. # # Later, once setup() has been called we should have all build # dependencies included via setup_requires available. distutils needs # to be able to access the user_options as a *class* attribute before # the class has been initialized, but we do need to be able to # enumerate the options for the correct base class at that point @classproperty def user_options(cls): from distutils import core if core._setup_distribution is None: # We haven't gotten into setup() yet, and the Distribution has # not yet been initialized return cls._user_options return cls._final_class.user_options @classproperty def boolean_options(cls): # Similar to user_options above from distutils import core if core._setup_distribution is None: # We haven't gotten into setup() yet, and the Distribution has # not yet been initialized return cls._boolean_options return cls._final_class.boolean_options @classproperty def help_options(cls): # Similar to user_options above from distutils import core if core._setup_distribution is None: # We haven't gotten into setup() yet, and the Distribution has # not yet been initialized return cls._help_options return cls._final_class.help_options @classproperty(lazy=True) def _final_class(cls): """ Late determination of what the build_ext base class should be, depending on whether or not Cython is available. """ uses_cython = should_build_with_cython(cls.package_name, cls.is_release) if uses_cython: # We need to decide late on whether or not to use Cython's # build_ext (since Cython may not be available earlier in the # setup.py if it was brought in via setup_requires) try: from Cython.Distutils.old_build_ext import old_build_ext as base_cls except ImportError: from Cython.Distutils import build_ext as base_cls else: base_cls = SetuptoolsBuildExt # Create and return an instance of a new class based on this class # using one of the above possible base classes def merge_options(attr): base = getattr(base_cls, attr) ours = getattr(cls, '_' + attr) all_base = set(opt[0] for opt in base) return base + [opt for opt in ours if opt[0] not in all_base] boolean_options = (base_cls.boolean_options + [opt for opt in cls._boolean_options if opt not in base_cls.boolean_options]) members = dict(cls.__dict__) members.update({ 'user_options': merge_options('user_options'), 'help_options': merge_options('help_options'), 'boolean_options': boolean_options, 'uses_cython': uses_cython, }) # Update the base class for the original build_ext command build_ext.__bases__ = (base_cls, object) # Create a new class for the existing class, but now with the # appropriate base class depending on whether or not to use Cython. # Ensure that object is one of the bases to make a new-style class. return type(cls.__name__, (build_ext,), members) def __new__(cls, *args, **kwargs): # By the time the command is actually instantialized, the # Distribution instance for the build has been instantiated, which # means setup_requires has been processed--now we can determine # what base class we can use for the actual build, and return an # instance of a build_ext command that uses that base class (right # now the options being Cython.Distutils.build_ext, or the stock # setuptools build_ext) new_cls = super(build_ext, cls._final_class).__new__( cls._final_class) # Since the new cls is not a subclass of the original cls, we must # manually call its __init__ new_cls.__init__(*args, **kwargs) return new_cls def finalize_options(self): # Add a copy of the _compiler.so module as well, but only if there # are in fact C modules to compile (otherwise there's no reason to # include a record of the compiler used) # Note, self.extensions may not be set yet, but # self.distribution.ext_modules is where any extension modules # passed to setup() can be found self._adjust_compiler() extensions = self.distribution.ext_modules if extensions: build_py = self.get_finalized_command('build_py') package_dir = build_py.get_package_dir(packagename) src_path = os.path.relpath( os.path.join(os.path.dirname(__file__), 'src')) shutil.copy(os.path.join(src_path, 'compiler.c'), os.path.join(package_dir, '_compiler.c')) ext = Extension(self.package_name + '._compiler', [os.path.join(package_dir, '_compiler.c')]) extensions.insert(0, ext) super(build_ext, self).finalize_options() # Generate if self.uses_cython: try: from Cython import __version__ as cython_version except ImportError: # This shouldn't happen if we made it this far cython_version = None if (cython_version is not None and cython_version != self.uses_cython): self.force_rebuild = True # Update the used cython version self.uses_cython = cython_version # Regardless of the value of the '--force' option, force a rebuild # if the debug flag changed from the last build if self.force_rebuild: self.force = True def run(self): # For extensions that require 'numpy' in their include dirs, # replace 'numpy' with the actual paths np_include = None for extension in self.extensions: if 'numpy' in extension.include_dirs: if np_include is None: np_include = get_numpy_include_path() idx = extension.include_dirs.index('numpy') extension.include_dirs.insert(idx, np_include) extension.include_dirs.remove('numpy') self._check_cython_sources(extension) super(build_ext, self).run() # Update cython_version.py if building with Cython try: cython_version = get_pkg_version_module( packagename, fromlist=['cython_version'])[0] except (AttributeError, ImportError): cython_version = 'unknown' if self.uses_cython and self.uses_cython != cython_version: build_py = self.get_finalized_command('build_py') package_dir = build_py.get_package_dir(packagename) cython_py = os.path.join(package_dir, 'cython_version.py') with open(cython_py, 'w') as f: f.write('# Generated file; do not modify\n') f.write('cython_version = {0!r}\n'.format(self.uses_cython)) if os.path.isdir(self.build_lib): # The build/lib directory may not exist if the build_py # command was not previously run, which may sometimes be # the case self.copy_file(cython_py, os.path.join(self.build_lib, cython_py), preserve_mode=False) invalidate_caches() def _adjust_compiler(self): """ This function detects broken compilers and switches to another. If the environment variable CC is explicitly set, or a compiler is specified on the commandline, no override is performed -- the purpose here is to only override a default compiler. The specific compilers with problems are: * The default compiler in XCode-4.2, llvm-gcc-4.2, segfaults when compiling wcslib. The set of broken compilers can be updated by changing the compiler_mapping variable. It is a list of 2-tuples where the first in the pair is a regular expression matching the version of the broken compiler, and the second is the compiler to change to. """ if 'CC' in os.environ: # Check that CC is not set to llvm-gcc-4.2 c_compiler = os.environ['CC'] try: version = get_compiler_version(c_compiler) except OSError: msg = textwrap.dedent( """ The C compiler set by the CC environment variable: {compiler:s} cannot be found or executed. """.format(compiler=c_compiler)) log.warn(msg) sys.exit(1) for broken, fixed in self._broken_compiler_mapping: if re.match(broken, version): msg = textwrap.dedent( """Compiler specified by CC environment variable ({compiler:s}:{version:s}) will fail to compile {pkg:s}. Please set CC={fixed:s} and try again. You can do this, for example, by running: CC={fixed:s} python setup.py where is the command you ran. """.format(compiler=c_compiler, version=version, pkg=self.package_name, fixed=fixed)) log.warn(msg) sys.exit(1) # If C compiler is set via CC, and isn't broken, we are good to go. We # should definitely not try accessing the compiler specified by # ``sysconfig.get_config_var('CC')`` lower down, because this may fail # if the compiler used to compile Python is missing (and maybe this is # why the user is setting CC). For example, the official Python 2.7.3 # MacOS X binary was compiled with gcc-4.2, which is no longer available # in XCode 4. return if self.compiler is not None: # At this point, self.compiler will be set only if a compiler # was specified in the command-line or via setup.cfg, in which # case we don't do anything return compiler_type = ccompiler.get_default_compiler() if compiler_type == 'unix': # We have to get the compiler this way, as this is the one that is # used if os.environ['CC'] is not set. It is actually read in from # the Python Makefile. Note that this is not necessarily the same # compiler as returned by ccompiler.new_compiler() c_compiler = sysconfig.get_config_var('CC') try: version = get_compiler_version(c_compiler) except OSError: msg = textwrap.dedent( """ The C compiler used to compile Python {compiler:s}, and which is normally used to compile C extensions, is not available. You can explicitly specify which compiler to use by setting the CC environment variable, for example: CC=gcc python setup.py or if you are using MacOS X, you can try: CC=clang python setup.py """.format(compiler=c_compiler)) log.warn(msg) sys.exit(1) for broken, fixed in self._broken_compiler_mapping: if re.match(broken, version): os.environ['CC'] = fixed break def _check_cython_sources(self, extension): """ Where relevant, make sure that the .c files associated with .pyx modules are present (if building without Cython installed). """ # Determine the compiler we'll be using if self.compiler is None: compiler = get_default_compiler() else: compiler = self.compiler # Replace .pyx with C-equivalents, unless c files are missing for jdx, src in enumerate(extension.sources): base, ext = os.path.splitext(src) pyxfn = base + '.pyx' cfn = base + '.c' cppfn = base + '.cpp' if not os.path.isfile(pyxfn): continue if self.uses_cython: extension.sources[jdx] = pyxfn else: if os.path.isfile(cfn): extension.sources[jdx] = cfn elif os.path.isfile(cppfn): extension.sources[jdx] = cppfn else: msg = ( 'Could not find C/C++ file {0}.(c/cpp) for Cython ' 'file {1} when building extension {2}. Cython ' 'must be installed to build from a git ' 'checkout.'.format(base, pyxfn, extension.name)) raise IOError(errno.ENOENT, msg, cfn) # Current versions of Cython use deprecated Numpy API features # the use of which produces a few warnings when compiling. # These additional flags should squelch those warnings. # TODO: Feel free to remove this if/when a Cython update # removes use of the deprecated Numpy API if compiler == 'unix': extension.extra_compile_args.extend([ '-Wp,-w', '-Wno-unused-function']) return build_ext regions-0.4/astropy_helpers/astropy_helpers/commands/build_py.py0000644000076600000240000000265613336766207025542 0ustar deilstaff00000000000000from setuptools.command.build_py import build_py as SetuptoolsBuildPy from ..utils import _get_platlib_dir class AstropyBuildPy(SetuptoolsBuildPy): user_options = SetuptoolsBuildPy.user_options[:] boolean_options = SetuptoolsBuildPy.boolean_options[:] def finalize_options(self): # Update build_lib settings from the build command to always put # build files in platform-specific subdirectories of build/, even # for projects with only pure-Python source (this is desirable # specifically for support of multiple Python version). build_cmd = self.get_finalized_command('build') platlib_dir = _get_platlib_dir(build_cmd) build_cmd.build_purelib = platlib_dir build_cmd.build_lib = platlib_dir self.build_lib = platlib_dir SetuptoolsBuildPy.finalize_options(self) def run_2to3(self, files, doctests=False): # Filter the files to exclude things that shouldn't be 2to3'd skip_2to3 = self.distribution.skip_2to3 filtered_files = [] for filename in files: for package in skip_2to3: if filename[len(self.build_lib) + 1:].startswith(package): break else: filtered_files.append(filename) SetuptoolsBuildPy.run_2to3(self, filtered_files, doctests) def run(self): # first run the normal build_py SetuptoolsBuildPy.run(self) regions-0.4/astropy_helpers/astropy_helpers/commands/build_sphinx.py0000644000076600000240000002526713467311012026407 0ustar deilstaff00000000000000from __future__ import print_function import inspect import os import pkgutil import re import shutil import subprocess import sys import textwrap import warnings from distutils import log from distutils.cmd import DistutilsOptionError import sphinx from sphinx.setup_command import BuildDoc as SphinxBuildDoc from ..utils import minversion, AstropyDeprecationWarning PY3 = sys.version_info[0] >= 3 class AstropyBuildDocs(SphinxBuildDoc): """ A version of the ``build_docs`` command that uses the version of Astropy that is built by the setup ``build`` command, rather than whatever is installed on the system. To build docs against the installed version, run ``make html`` in the ``astropy/docs`` directory. This also automatically creates the docs/_static directories--this is needed because GitHub won't create the _static dir because it has no tracked files. """ description = 'Build Sphinx documentation for Astropy environment' user_options = SphinxBuildDoc.user_options[:] user_options.append( ('warnings-returncode', 'w', 'Parses the sphinx output and sets the return code to 1 if there ' 'are any warnings. Note that this will cause the sphinx log to ' 'only update when it completes, rather than continuously as is ' 'normally the case.')) user_options.append( ('clean-docs', 'l', 'Completely clean previous builds, including ' 'automodapi-generated files before building new ones')) user_options.append( ('no-intersphinx', 'n', 'Skip intersphinx, even if conf.py says to use it')) user_options.append( ('open-docs-in-browser', 'o', 'Open the docs in a browser (using the webbrowser module) if the ' 'build finishes successfully.')) boolean_options = SphinxBuildDoc.boolean_options[:] boolean_options.append('warnings-returncode') boolean_options.append('clean-docs') boolean_options.append('no-intersphinx') boolean_options.append('open-docs-in-browser') _self_iden_rex = re.compile(r"self\.([^\d\W][\w]+)", re.UNICODE) def initialize_options(self): SphinxBuildDoc.initialize_options(self) self.clean_docs = False self.no_intersphinx = False self.open_docs_in_browser = False self.warnings_returncode = False def finalize_options(self): # We need to make sure this is set before finalize_options otherwise # the default is set to build/sphinx. We also need the absolute path # as in some Sphinx versions, the path is otherwise interpreted as # docs/docs/_build. if self.build_dir is None: self.build_dir = os.path.abspath('docs/_build') else: self.build_dir = os.path.abspath(self.build_dir) SphinxBuildDoc.finalize_options(self) # Clear out previous sphinx builds, if requested if self.clean_docs: dirstorm = [os.path.join(self.source_dir, 'api'), os.path.join(self.source_dir, 'generated')] if self.build_dir is None: dirstorm.append('docs/_build') else: dirstorm.append(self.build_dir) for d in dirstorm: if os.path.isdir(d): log.info('Cleaning directory ' + d) shutil.rmtree(d) else: log.info('Not cleaning directory ' + d + ' because ' 'not present or not a directory') def run(self): # TODO: Break this method up into a few more subroutines and # document them better import webbrowser if PY3: from urllib.request import pathname2url else: from urllib import pathname2url # This is used at the very end of `run` to decide if sys.exit should # be called. If it's None, it won't be. retcode = None # If possible, create the _static dir if self.build_dir is not None: # the _static dir should be in the same place as the _build dir # for Astropy basedir, subdir = os.path.split(self.build_dir) if subdir == '': # the path has a trailing /... basedir, subdir = os.path.split(basedir) staticdir = os.path.join(basedir, '_static') if os.path.isfile(staticdir): raise DistutilsOptionError( 'Attempted to build_docs in a location where' + staticdir + 'is a file. Must be a directory.') self.mkpath(staticdir) # Now make sure Astropy is built and determine where it was built build_cmd = self.reinitialize_command('build') build_cmd.inplace = 0 self.run_command('build') build_cmd = self.get_finalized_command('build') build_cmd_path = os.path.abspath(build_cmd.build_lib) ah_importer = pkgutil.get_importer('astropy_helpers') if ah_importer is None: ah_path = '.' else: ah_path = os.path.abspath(ah_importer.path) # Now generate the source for and spawn a new process that runs the # command. This is needed to get the correct imports for the built # version runlines, runlineno = inspect.getsourcelines(SphinxBuildDoc.run) subproccode = textwrap.dedent(""" from sphinx.setup_command import * os.chdir({srcdir!r}) sys.path.insert(0, {build_cmd_path!r}) sys.path.insert(0, {ah_path!r}) """).format(build_cmd_path=build_cmd_path, ah_path=ah_path, srcdir=self.source_dir) # runlines[1:] removes 'def run(self)' on the first line subproccode += textwrap.dedent(''.join(runlines[1:])) # All "self.foo" in the subprocess code needs to be replaced by the # values taken from the current self in *this* process subproccode = self._self_iden_rex.split(subproccode) for i in range(1, len(subproccode), 2): iden = subproccode[i] val = getattr(self, iden) if iden.endswith('_dir'): # Directories should be absolute, because the `chdir` call # in the new process moves to a different directory subproccode[i] = repr(os.path.abspath(val)) else: subproccode[i] = repr(val) subproccode = ''.join(subproccode) optcode = textwrap.dedent(""" class Namespace(object): pass self = Namespace() self.pdb = {pdb!r} self.verbosity = {verbosity!r} self.traceback = {traceback!r} """).format(pdb=getattr(self, 'pdb', False), verbosity=getattr(self, 'verbosity', 0), traceback=getattr(self, 'traceback', False)) subproccode = optcode + subproccode # This is a quick gross hack, but it ensures that the code grabbed from # SphinxBuildDoc.run will work in Python 2 if it uses the print # function if minversion(sphinx, '1.3'): subproccode = 'from __future__ import print_function' + subproccode if self.no_intersphinx: # the confoverrides variable in sphinx.setup_command.BuildDoc can # be used to override the conf.py ... but this could well break # if future versions of sphinx change the internals of BuildDoc, # so remain vigilant! subproccode = subproccode.replace( 'confoverrides = {}', 'confoverrides = {\'intersphinx_mapping\':{}}') log.debug('Starting subprocess of {0} with python code:\n{1}\n' '[CODE END])'.format(sys.executable, subproccode)) # To return the number of warnings, we need to capture stdout. This # prevents a continuous updating at the terminal, but there's no # apparent way around this. if self.warnings_returncode: proc = subprocess.Popen([sys.executable, '-c', subproccode], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) retcode = 1 with proc.stdout: for line in iter(proc.stdout.readline, b''): line = line.strip(b'\r\n') print(line.decode('utf-8')) if 'build succeeded.' == line.decode('utf-8'): retcode = 0 # Poll to set proc.retcode proc.wait() if retcode != 0: if os.environ.get('TRAVIS', None) == 'true': # this means we are in the travis build, so customize # the message appropriately. msg = ('The build_docs travis build FAILED ' 'because sphinx issued documentation ' 'warnings (scroll up to see the warnings).') else: # standard failure message msg = ('build_docs returning a non-zero exit ' 'code because sphinx issued documentation ' 'warnings.') log.warn(msg) else: proc = subprocess.Popen([sys.executable], stdin=subprocess.PIPE) proc.communicate(subproccode.encode('utf-8')) if proc.returncode == 0: if self.open_docs_in_browser: if self.builder == 'html': absdir = os.path.abspath(self.builder_target_dir) index_path = os.path.join(absdir, 'index.html') fileurl = 'file://' + pathname2url(index_path) webbrowser.open(fileurl) else: log.warn('open-docs-in-browser option was given, but ' 'the builder is not html! Ignoring.') else: log.warn('Sphinx Documentation subprocess failed with return ' 'code ' + str(proc.returncode)) retcode = proc.returncode if retcode is not None: # this is potentially dangerous in that there might be something # after the call to `setup` in `setup.py`, and exiting here will # prevent that from running. But there's no other apparent way # to signal what the return code should be. sys.exit(retcode) class AstropyBuildSphinx(AstropyBuildDocs): # pragma: no cover description = 'deprecated alias to the build_docs command' def run(self): warnings.warn( 'The "build_sphinx" command is now deprecated. Use' '"build_docs" instead.', AstropyDeprecationWarning) AstropyBuildDocs.run(self) regions-0.4/astropy_helpers/astropy_helpers/commands/install.py0000644000076600000240000000074613336766207025377 0ustar deilstaff00000000000000from setuptools.command.install import install as SetuptoolsInstall from ..utils import _get_platlib_dir class AstropyInstall(SetuptoolsInstall): user_options = SetuptoolsInstall.user_options[:] boolean_options = SetuptoolsInstall.boolean_options[:] def finalize_options(self): build_cmd = self.get_finalized_command('build') platlib_dir = _get_platlib_dir(build_cmd) self.build_lib = platlib_dir SetuptoolsInstall.finalize_options(self) regions-0.4/astropy_helpers/astropy_helpers/commands/install_lib.py0000644000076600000240000000100013336766207026205 0ustar deilstaff00000000000000from setuptools.command.install_lib import install_lib as SetuptoolsInstallLib from ..utils import _get_platlib_dir class AstropyInstallLib(SetuptoolsInstallLib): user_options = SetuptoolsInstallLib.user_options[:] boolean_options = SetuptoolsInstallLib.boolean_options[:] def finalize_options(self): build_cmd = self.get_finalized_command('build') platlib_dir = _get_platlib_dir(build_cmd) self.build_dir = platlib_dir SetuptoolsInstallLib.finalize_options(self) regions-0.4/astropy_helpers/astropy_helpers/commands/register.py0000644000076600000240000000454713336766207025560 0ustar deilstaff00000000000000from setuptools.command.register import register as SetuptoolsRegister class AstropyRegister(SetuptoolsRegister): """Extends the built in 'register' command to support a ``--hidden`` option to make the registered version hidden on PyPI by default. The result of this is that when a version is registered as "hidden" it can still be downloaded from PyPI, but it does not show up in the list of actively supported versions under http://pypi.python.org/pypi/astropy, and is not set as the most recent version. Although this can always be set through the web interface it may be more convenient to be able to specify via the 'register' command. Hidden may also be considered a safer default when running the 'register' command, though this command uses distutils' normal behavior if the ``--hidden`` option is omitted. """ user_options = SetuptoolsRegister.user_options + [ ('hidden', None, 'mark this release as hidden on PyPI by default') ] boolean_options = SetuptoolsRegister.boolean_options + ['hidden'] def initialize_options(self): SetuptoolsRegister.initialize_options(self) self.hidden = False def build_post_data(self, action): data = SetuptoolsRegister.build_post_data(self, action) if action == 'submit' and self.hidden: data['_pypi_hidden'] = '1' return data def _set_config(self): # The original register command is buggy--if you use .pypirc with a # server-login section *at all* the repository you specify with the -r # option will be overwritten with either the repository in .pypirc or # with the default, # If you do not have a .pypirc using the -r option will just crash. # Way to go distutils # If we don't set self.repository back to a default value _set_config # can crash if there was a user-supplied value for this option; don't # worry, we'll get the real value back afterwards self.repository = 'pypi' SetuptoolsRegister._set_config(self) options = self.distribution.get_option_dict('register') if 'repository' in options: source, value = options['repository'] # Really anything that came from setup.cfg or the command line # should override whatever was in .pypirc self.repository = value regions-0.4/astropy_helpers/astropy_helpers/commands/setup_package.py0000644000076600000240000000017013336766207026533 0ustar deilstaff00000000000000from os.path import join def get_package_data(): return {'astropy_helpers.commands': [join('src', 'compiler.c')]} regions-0.4/astropy_helpers/astropy_helpers/commands/src/0000755000076600000240000000000013501657425024132 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/commands/src/compiler.c0000644000076600000240000000573113336766207026123 0ustar deilstaff00000000000000#include /*************************************************************************** * Macros for determining the compiler version. * * These are borrowed from boost, and majorly abridged to include only * the compilers we care about. ***************************************************************************/ #ifndef PY3K #if PY_MAJOR_VERSION >= 3 #define PY3K 1 #else #define PY3K 0 #endif #endif #define STRINGIZE(X) DO_STRINGIZE(X) #define DO_STRINGIZE(X) #X #if defined __clang__ /* Clang C++ emulates GCC, so it has to appear early. */ # define COMPILER "Clang version " __clang_version__ #elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC) /* Intel */ # if defined(__INTEL_COMPILER) # define INTEL_VERSION __INTEL_COMPILER # elif defined(__ICL) # define INTEL_VERSION __ICL # elif defined(__ICC) # define INTEL_VERSION __ICC # elif defined(__ECC) # define INTEL_VERSION __ECC # endif # define COMPILER "Intel C compiler version " STRINGIZE(INTEL_VERSION) #elif defined(__GNUC__) /* gcc */ # define COMPILER "GCC version " __VERSION__ #elif defined(__SUNPRO_CC) /* Sun Workshop Compiler */ # define COMPILER "Sun compiler version " STRINGIZE(__SUNPRO_CC) #elif defined(_MSC_VER) /* Microsoft Visual C/C++ Must be last since other compilers define _MSC_VER for compatibility as well */ # if _MSC_VER < 1200 # define COMPILER_VERSION 5.0 # elif _MSC_VER < 1300 # define COMPILER_VERSION 6.0 # elif _MSC_VER == 1300 # define COMPILER_VERSION 7.0 # elif _MSC_VER == 1310 # define COMPILER_VERSION 7.1 # elif _MSC_VER == 1400 # define COMPILER_VERSION 8.0 # elif _MSC_VER == 1500 # define COMPILER_VERSION 9.0 # elif _MSC_VER == 1600 # define COMPILER_VERSION 10.0 # else # define COMPILER_VERSION _MSC_VER # endif # define COMPILER "Microsoft Visual C++ version " STRINGIZE(COMPILER_VERSION) #else /* Fallback */ # define COMPILER "Unknown compiler" #endif /*************************************************************************** * Module-level ***************************************************************************/ struct module_state { /* The Sun compiler can't handle empty structs */ #if defined(__SUNPRO_C) || defined(_MSC_VER) int _dummy; #endif }; #if PY3K static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "_compiler", NULL, sizeof(struct module_state), NULL, NULL, NULL, NULL, NULL }; #define INITERROR return NULL PyMODINIT_FUNC PyInit__compiler(void) #else #define INITERROR return PyMODINIT_FUNC init_compiler(void) #endif { PyObject* m; #if PY3K m = PyModule_Create(&moduledef); #else m = Py_InitModule3("_compiler", NULL, NULL); #endif if (m == NULL) INITERROR; PyModule_AddStringConstant(m, "compiler", COMPILER); #if PY3K return m; #endif } regions-0.4/astropy_helpers/astropy_helpers/commands/test.py0000644000076600000240000000252413336766207024704 0ustar deilstaff00000000000000""" Different implementations of the ``./setup.py test`` command depending on what's locally available. If Astropy v1.1.0.dev or later is available it should be possible to import AstropyTest from ``astropy.tests.command``. If ``astropy`` can be imported but not ``astropy.tests.command`` (i.e. an older version of Astropy), we can use the backwards-compat implementation of the command. If Astropy can't be imported at all then there is a skeleton implementation that allows users to at least discover the ``./setup.py test`` command and learn that they need Astropy to run it. """ # Previously these except statements caught only ImportErrors, but there are # some other obscure exceptional conditions that can occur when importing # astropy.tests (at least on older versions) that can cause these imports to # fail try: import astropy # noqa try: from astropy.tests.command import AstropyTest except Exception: from ._test_compat import AstropyTest except Exception: # No astropy at all--provide the dummy implementation from ._dummy import _DummyCommand class AstropyTest(_DummyCommand): command_name = 'test' description = 'Run the tests for this package' error_msg = ( "The 'test' command requires the astropy package to be " "installed and importable.") regions-0.4/astropy_helpers/astropy_helpers/compat/0000755000076600000240000000000013501657425023025 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/compat/__init__.py0000644000076600000240000000056013336766207025144 0ustar deilstaff00000000000000def _fix_user_options(options): """ This is for Python 2.x and 3.x compatibility. distutils expects Command options to all be byte strings on Python 2 and Unicode strings on Python 3. """ def to_str_or_none(x): if x is None: return None return str(x) return [tuple(to_str_or_none(x) for x in y) for y in options] regions-0.4/astropy_helpers/astropy_helpers/conftest.py0000644000076600000240000000315713336766207023754 0ustar deilstaff00000000000000# This file contains settings for pytest that are specific to astropy-helpers. # Since we run many of the tests in sub-processes, we need to collect coverage # data inside each subprocess and then combine it into a single .coverage file. # To do this we set up a list which run_setup appends coverage objects to. # This is not intended to be used by packages other than astropy-helpers. import os from collections import defaultdict try: from coverage import CoverageData except ImportError: HAS_COVERAGE = False else: HAS_COVERAGE = True if HAS_COVERAGE: SUBPROCESS_COVERAGE = [] def pytest_configure(config): if HAS_COVERAGE: SUBPROCESS_COVERAGE[:] = [] def pytest_unconfigure(config): if HAS_COVERAGE: # We create an empty coverage data object combined_cdata = CoverageData() lines = defaultdict(list) for cdata in SUBPROCESS_COVERAGE: # For each CoverageData object, we go through all the files and # change the filename from one which might be a temporary path # to the local filename. We then only keep files that actually # exist. for filename in cdata.measured_files(): try: pos = filename.rindex('astropy_helpers') except ValueError: continue short_filename = filename[pos:] if os.path.exists(short_filename): lines[os.path.abspath(short_filename)].extend(cdata.lines(filename)) combined_cdata.add_lines(lines) combined_cdata.write_file('.coverage.subprocess') regions-0.4/astropy_helpers/astropy_helpers/distutils_helpers.py0000644000076600000240000001736213336766207025700 0ustar deilstaff00000000000000""" This module contains various utilities for introspecting the distutils module and the setup process. Some of these utilities require the `astropy_helpers.setup_helpers.register_commands` function to be called first, as it will affect introspection of setuptools command-line arguments. Other utilities in this module do not have that restriction. """ import os import sys from distutils import ccompiler, log from distutils.dist import Distribution from distutils.errors import DistutilsError from .utils import silence # This function, and any functions that call it, require the setup in # `astropy_helpers.setup_helpers.register_commands` to be run first. def get_dummy_distribution(): """ Returns a distutils Distribution object used to instrument the setup environment before calling the actual setup() function. """ from .setup_helpers import _module_state if _module_state['registered_commands'] is None: raise RuntimeError( 'astropy_helpers.setup_helpers.register_commands() must be ' 'called before using ' 'astropy_helpers.setup_helpers.get_dummy_distribution()') # Pre-parse the Distutils command-line options and config files to if # the option is set. dist = Distribution({'script_name': os.path.basename(sys.argv[0]), 'script_args': sys.argv[1:]}) dist.cmdclass.update(_module_state['registered_commands']) with silence(): try: dist.parse_config_files() dist.parse_command_line() except (DistutilsError, AttributeError, SystemExit): # Let distutils handle DistutilsErrors itself AttributeErrors can # get raise for ./setup.py --help SystemExit can be raised if a # display option was used, for example pass return dist def get_distutils_option(option, commands): """ Returns the value of the given distutils option. Parameters ---------- option : str The name of the option commands : list of str The list of commands on which this option is available Returns ------- val : str or None the value of the given distutils option. If the option is not set, returns None. """ dist = get_dummy_distribution() for cmd in commands: cmd_opts = dist.command_options.get(cmd) if cmd_opts is not None and option in cmd_opts: return cmd_opts[option][1] else: return None def get_distutils_build_option(option): """ Returns the value of the given distutils build option. Parameters ---------- option : str The name of the option Returns ------- val : str or None The value of the given distutils build option. If the option is not set, returns None. """ return get_distutils_option(option, ['build', 'build_ext', 'build_clib']) def get_distutils_install_option(option): """ Returns the value of the given distutils install option. Parameters ---------- option : str The name of the option Returns ------- val : str or None The value of the given distutils build option. If the option is not set, returns None. """ return get_distutils_option(option, ['install']) def get_distutils_build_or_install_option(option): """ Returns the value of the given distutils build or install option. Parameters ---------- option : str The name of the option Returns ------- val : str or None The value of the given distutils build or install option. If the option is not set, returns None. """ return get_distutils_option(option, ['build', 'build_ext', 'build_clib', 'install']) def get_compiler_option(): """ Determines the compiler that will be used to build extension modules. Returns ------- compiler : str The compiler option specified for the build, build_ext, or build_clib command; or the default compiler for the platform if none was specified. """ compiler = get_distutils_build_option('compiler') if compiler is None: return ccompiler.get_default_compiler() return compiler def add_command_option(command, name, doc, is_bool=False): """ Add a custom option to a setup command. Issues a warning if the option already exists on that command. Parameters ---------- command : str The name of the command as given on the command line name : str The name of the build option doc : str A short description of the option, for the `--help` message is_bool : bool, optional When `True`, the option is a boolean option and doesn't require an associated value. """ dist = get_dummy_distribution() cmdcls = dist.get_command_class(command) if (hasattr(cmdcls, '_astropy_helpers_options') and name in cmdcls._astropy_helpers_options): return attr = name.replace('-', '_') if hasattr(cmdcls, attr): raise RuntimeError( '{0!r} already has a {1!r} class attribute, barring {2!r} from ' 'being usable as a custom option name.'.format(cmdcls, attr, name)) for idx, cmd in enumerate(cmdcls.user_options): if cmd[0] == name: log.warn('Overriding existing {0!r} option ' '{1!r}'.format(command, name)) del cmdcls.user_options[idx] if name in cmdcls.boolean_options: cmdcls.boolean_options.remove(name) break cmdcls.user_options.append((name, None, doc)) if is_bool: cmdcls.boolean_options.append(name) # Distutils' command parsing requires that a command object have an # attribute with the same name as the option (with '-' replaced with '_') # in order for that option to be recognized as valid setattr(cmdcls, attr, None) # This caches the options added through add_command_option so that if it is # run multiple times in the same interpreter repeated adds are ignored # (this way we can still raise a RuntimeError if a custom option overrides # a built-in option) if not hasattr(cmdcls, '_astropy_helpers_options'): cmdcls._astropy_helpers_options = set([name]) else: cmdcls._astropy_helpers_options.add(name) def get_distutils_display_options(): """ Returns a set of all the distutils display options in their long and short forms. These are the setup.py arguments such as --name or --version which print the project's metadata and then exit. Returns ------- opts : set The long and short form display option arguments, including the - or -- """ short_display_opts = set('-' + o[1] for o in Distribution.display_options if o[1]) long_display_opts = set('--' + o[0] for o in Distribution.display_options) # Include -h and --help which are not explicitly listed in # Distribution.display_options (as they are handled by optparse) short_display_opts.add('-h') long_display_opts.add('--help') # This isn't the greatest approach to hardcode these commands. # However, there doesn't seem to be a good way to determine # whether build *will be* run as part of the command at this # phase. display_commands = set([ 'clean', 'register', 'setopt', 'saveopts', 'egg_info', 'alias']) return short_display_opts.union(long_display_opts.union(display_commands)) def is_distutils_display_option(): """ Returns True if sys.argv contains any of the distutils display options such as --version or --name. """ display_options = get_distutils_display_options() return bool(set(sys.argv[1:]).intersection(display_options)) regions-0.4/astropy_helpers/astropy_helpers/extern/0000755000076600000240000000000013501657425023047 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/extern/__init__.py0000644000076600000240000000111513336766207025163 0ustar deilstaff00000000000000# The ``astropy_helpers.extern`` sub-module includes modules developed elsewhere # that are bundled here for convenience. At the moment, this consists of the # following two sphinx extensions: # # * `numpydoc `_, a Sphinx extension # developed as part of the Numpy project. This is used to parse docstrings # in Numpy format # # * `sphinx-automodapi `_, a Sphinx # developed as part of the Astropy project. This used to be developed directly # in ``astropy-helpers`` but is now a standalone package. regions-0.4/astropy_helpers/astropy_helpers/extern/automodapi/0000755000076600000240000000000013501657425025211 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/extern/automodapi/__init__.py0000644000076600000240000000002513477530461027321 0ustar deilstaff00000000000000__version__ = '0.11' regions-0.4/astropy_helpers/astropy_helpers/extern/automodapi/autodoc_enhancements.py0000644000076600000240000001242613467311012031744 0ustar deilstaff00000000000000""" Miscellaneous enhancements to help autodoc along. """ import inspect import sys import types import sphinx from distutils.version import LooseVersion from sphinx.ext.autodoc import AttributeDocumenter, ModuleDocumenter from sphinx.util.inspect import isdescriptor if sys.version_info[0] == 3: class_types = (type,) else: class_types = (type, types.ClassType) SPHINX_LT_15 = (LooseVersion(sphinx.__version__) < LooseVersion('1.5')) MethodDescriptorType = type(type.__subclasses__) # See # https://github.com/astropy/astropy-helpers/issues/116#issuecomment-71254836 # for further background on this. def type_object_attrgetter(obj, attr, *defargs): """ This implements an improved attrgetter for type objects (i.e. classes) that can handle class attributes that are implemented as properties on a metaclass. Normally `getattr` on a class with a `property` (say, "foo"), would return the `property` object itself. However, if the class has a metaclass which *also* defines a `property` named "foo", ``getattr(cls, 'foo')`` will find the "foo" property on the metaclass and resolve it. For the purposes of autodoc we just want to document the "foo" property defined on the class, not on the metaclass. For example:: >>> class Meta(type): ... @property ... def foo(cls): ... return 'foo' ... >>> class MyClass(metaclass=Meta): ... @property ... def foo(self): ... \"\"\"Docstring for MyClass.foo property.\"\"\" ... return 'myfoo' ... >>> getattr(MyClass, 'foo') 'foo' >>> type_object_attrgetter(MyClass, 'foo') >>> type_object_attrgetter(MyClass, 'foo').__doc__ 'Docstring for MyClass.foo property.' The last line of the example shows the desired behavior for the purposes of autodoc. """ for base in obj.__mro__: if attr in base.__dict__: if isinstance(base.__dict__[attr], property): # Note, this should only be used for properties--for any other # type of descriptor (classmethod, for example) this can mess # up existing expectations of what getattr(cls, ...) returns return base.__dict__[attr] break return getattr(obj, attr, *defargs) if SPHINX_LT_15: # Provided to work around a bug in Sphinx # See https://github.com/sphinx-doc/sphinx/pull/1843 class AttributeDocumenter(AttributeDocumenter): @classmethod def can_document_member(cls, member, membername, isattr, parent): non_attr_types = cls.method_types + class_types + \ (MethodDescriptorType,) isdatadesc = isdescriptor(member) and not \ isinstance(member, non_attr_types) and not \ type(member).__name__ == "instancemethod" # That last condition addresses an obscure case of C-defined # methods using a deprecated type in Python 3, that is not # otherwise exported anywhere by Python return isdatadesc or (not isinstance(parent, ModuleDocumenter) and not inspect.isroutine(member) and not isinstance(member, class_types)) def setup(app): # Must have the autodoc extension set up first so we can override it app.setup_extension('sphinx.ext.autodoc') # Need to import this too since it re-registers all the documenter types # =_= import sphinx.ext.autosummary.generate app.add_autodoc_attrgetter(type, type_object_attrgetter) if sphinx.version_info < (1, 4, 2): # this is a really ugly hack to supress a warning that sphinx 1.4 # generates when overriding an existing directive (which is *desired* # behavior here). As of sphinx v1.4.2, this has been fixed: # https://github.com/sphinx-doc/sphinx/issues/2451 # But we leave it in for 1.4.0/1.4.1 . But if the "needs_sphinx" is # eventually updated to >= 1.4.2, this should be removed entirely (in # favor of the line in the "else" clause) _oldwarn = app._warning _oldwarncount = app._warncount try: try: # *this* is in a try/finally because we don't want to force six as # a real dependency. In sphinx 1.4, six is a prerequisite, so # there's no issue. But in older sphinxes this may not be true... # but the inderlying warning is absent anyway so we let it slide. from six import StringIO app._warning = StringIO() except ImportError: pass app.add_autodocumenter(AttributeDocumenter) finally: app._warning = _oldwarn app._warncount = _oldwarncount else: suppress_warnigns_orig = app.config.suppress_warnings[:] if 'app.add_directive' not in app.config.suppress_warnings: app.config.suppress_warnings.append('app.add_directive') try: app.add_autodocumenter(AttributeDocumenter) finally: app.config.suppress_warnings = suppress_warnigns_orig return {'parallel_read_safe': True, 'parallel_write_safe': True} regions-0.4/astropy_helpers/astropy_helpers/extern/automodapi/automodapi.py0000644000076600000240000004015213477530461027731 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ This directive takes a single argument that must be a module or package. It will produce a block of documentation that includes the docstring for the package, an :ref:`automodsumm` directive, and an :ref:`automod-diagram` if there are any classes in the module. If only the main docstring of the module/package is desired in the documentation, use `automodule`_ instead of `automodapi`_. It accepts the following options: * ``:include-all-objects:`` If present, include not just functions and classes, but all objects. This includes variables, for which a possible docstring after the variable definition will be shown. * ``:inheritance-diagram:`` / ``:no-inheritance-diagram:`` Specify whether or not to show the inheritance diagram for classes. This overrides the default global configuration set in ``automodapi_inheritance_diagram``. * ``:skip: str`` This option results in the specified object being skipped, that is the object will *not* be included in the generated documentation. This option may appear any number of times to skip multiple objects. * ``:no-main-docstr:`` If present, the docstring for the module/package will not be generated. The function and class tables will still be used, however. * ``:headings: str`` Specifies the characters (in one string) used as the heading levels used for the generated section. This must have at least 2 characters (any after 2 will be ignored). This also *must* match the rest of the documentation on this page for sphinx to be happy. Defaults to "-^", which matches the convention used for Python's documentation, assuming the automodapi call is inside a top-level section (which usually uses '='). * ``:no-heading:`` If specified do not create a top level heading for the section. That is, do not create a title heading with text like "packagename Package". The actual docstring for the package/module will still be shown, though, unless ``:no-main-docstr:`` is given. * ``:allowed-package-names: str`` Specifies the packages that functions/classes documented here are allowed to be from, as comma-separated list of package names. If not given, only objects that are actually in a subpackage of the package currently being documented are included. * ``:inherited-members:`` / ``:no-inherited-members:`` The global sphinx configuration option ``automodsumm_inherited_members`` decides if members that a class inherits from a base class are included in the generated documentation. The option ``:inherited-members:`` or ``:no-inherited-members:`` allows the user to overrride the global setting. This extension also adds four sphinx configuration options: * ``automodapi_inheritance_diagram`` Should be a boolean that indicates whether to show inheritance diagrams by default. This can be overriden on a case by case basis with ``:inheritance-diagram:`` and ``:no-inheritance-diagram:``. Defaults to ``True``. * ``automodapi_toctreedirnm`` This must be a string that specifies the name of the directory the automodsumm generated documentation ends up in. This directory path should be relative to the documentation root (e.g., same place as ``index.rst``). Defaults to ``'api'``. * ``automodapi_writereprocessed`` Should be a bool, and if `True`, will cause `automodapi`_ to write files with any `automodapi`_ sections replaced with the content Sphinx processes after `automodapi`_ has run. The output files are not actually used by sphinx, so this option is only for figuring out the cause of sphinx warnings or other debugging. Defaults to `False`. * ``automodsumm_inherited_members`` Should be a bool and if ``True`` members that a class inherits from a base class are included in the generated documentation. Defaults to ``False``. .. _automodule: http://sphinx-doc.org/latest/ext/autodoc.html?highlight=automodule#directive-automodule """ # Implementation note: # The 'automodapi' directive is not actually implemented as a docutils # directive. Instead, this extension searches for the 'automodapi' text in # all sphinx documents, and replaces it where necessary from a template built # into this extension. This is necessary because automodsumm (and autosummary) # use the "builder-inited" event, which comes before the directives are # actually built. import inspect import io import os import re import sys from .utils import find_mod_objs if sys.version_info[0] == 3: text_type = str else: text_type = unicode automod_templ_modheader = """ {modname} {pkgormod} {modhds}{pkgormodhds} {automoduleline} """ automod_templ_classes = """ Classes {clshds} .. automodsumm:: {modname} :classes-only: {clsfuncoptions} """ automod_templ_funcs = """ Functions {funchds} .. automodsumm:: {modname} :functions-only: {clsfuncoptions} """ automod_templ_vars = """ Variables {otherhds} .. automodsumm:: {modname} :variables-only: {clsfuncoptions} """ automod_templ_inh = """ Class Inheritance Diagram {clsinhsechds} .. automod-diagram:: {modname} :private-bases: :parts: 1 {allowedpkgnms} {skip} """ _automodapirex = re.compile(r'^(?:\.\.\s+automodapi::\s*)([A-Za-z0-9_.]+)' r'\s*$((?:\n\s+:[a-zA-Z_\-]+:.*$)*)', flags=re.MULTILINE) # the last group of the above regex is intended to go into finall with the below _automodapiargsrex = re.compile(r':([a-zA-Z_\-]+):(.*)$', flags=re.MULTILINE) def automodapi_replace(sourcestr, app, dotoctree=True, docname=None, warnings=True): """ Replaces `sourcestr`'s entries of ".. automdapi::" with the automodapi template form based on provided options. This is used with the sphinx event 'source-read' to replace `automodapi`_ entries before sphinx actually processes them, as automodsumm needs the code to be present to generate stub documentation. Parameters ---------- sourcestr : str The string with sphinx source to be checked for automodapi replacement. app : `sphinx.application.Application` The sphinx application. dotoctree : bool If `True`, a ":toctree:" option will be added in the ".. automodsumm::" sections of the template, pointing to the appropriate "generated" directory based on the Astropy convention (e.g. in ``docs/api``) docname : str The name of the file for this `sourcestr` (if known - if not, it can be `None`). If not provided and `dotoctree` is `True`, the generated files may end up in the wrong place. warnings : bool If `False`, all warnings that would normally be issued are silenced. Returns ------- newstr :str The string with automodapi entries replaced with the correct sphinx markup. """ spl = _automodapirex.split(sourcestr) if len(spl) > 1: # automodsumm is in this document # Use app.srcdir because api folder should be inside source folder not # at folder where sphinx is run. if dotoctree: toctreestr = ':toctree: ' api_dir = os.path.join(app.srcdir, app.config.automodapi_toctreedirnm) if docname is None: doc_path = '.' else: doc_path = os.path.join(app.srcdir, docname) toctreestr += os.path.relpath(api_dir, os.path.dirname(doc_path)).replace(os.sep, '/') else: toctreestr = '' newstrs = [spl[0]] for grp in range(len(spl) // 3): modnm = spl[grp * 3 + 1] # find where this is in the document for warnings if docname is None: location = None else: location = (docname, spl[0].count('\n')) # initialize default options toskip = [] inhdiag = app.config.automodapi_inheritance_diagram maindocstr = True top_head = True hds = '-^' allowedpkgnms = [] allowothers = False # look for actual options unknownops = [] inherited_members = None for opname, args in _automodapiargsrex.findall(spl[grp * 3 + 2]): if opname == 'skip': toskip.append(args.strip()) elif opname == 'inheritance-diagram': inhdiag = True elif opname == 'no-inheritance-diagram': inhdiag = False elif opname == 'no-main-docstr': maindocstr = False elif opname == 'headings': hds = args elif opname == 'no-heading': top_head = False elif opname == 'allowed-package-names': allowedpkgnms.append(args.strip()) elif opname == 'inherited-members': inherited_members = True elif opname == 'no-inherited-members': inherited_members = False elif opname == 'include-all-objects': allowothers = True else: unknownops.append(opname) # join all the allowedpkgnms if len(allowedpkgnms) == 0: allowedpkgnms = '' onlylocals = True else: allowedpkgnms = ':allowed-package-names: ' + ','.join(allowedpkgnms) onlylocals = allowedpkgnms # get the two heading chars if len(hds) < 2: msg = 'Not enough headings (got {0}, need 2), using default -^' if warnings: app.warn(msg.format(len(hds)), location) hds = '-^' h1, h2 = hds.lstrip()[:2] # tell sphinx that the remaining args are invalid. if len(unknownops) > 0 and app is not None: opsstrs = ','.join(unknownops) msg = 'Found additional options ' + opsstrs + ' in automodapi.' if warnings: app.warn(msg, location) ispkg, hascls, hasfuncs, hasother = _mod_info( modnm, toskip, onlylocals=onlylocals) # add automodule directive only if no-main-docstr isn't present if maindocstr: automodline = '.. automodule:: {modname}'.format(modname=modnm) else: automodline = '' if top_head: newstrs.append(automod_templ_modheader.format( modname=modnm, modhds=h1 * len(modnm), pkgormod='Package' if ispkg else 'Module', pkgormodhds=h1 * (8 if ispkg else 7), automoduleline=automodline)) # noqa else: newstrs.append(automod_templ_modheader.format( modname='', modhds='', pkgormod='', pkgormodhds='', automoduleline=automodline)) # construct the options for the class/function sections # start out indented at 4 spaces, but need to keep the indentation. clsfuncoptions = [] if toctreestr: clsfuncoptions.append(toctreestr) if toskip: clsfuncoptions.append(':skip: ' + ','.join(toskip)) if allowedpkgnms: clsfuncoptions.append(allowedpkgnms) if hascls: # This makes no sense unless there are classes. if inherited_members is True: clsfuncoptions.append(':inherited-members:') if inherited_members is False: clsfuncoptions.append(':no-inherited-members:') clsfuncoptionstr = '\n '.join(clsfuncoptions) if hasfuncs: newstrs.append(automod_templ_funcs.format( modname=modnm, funchds=h2 * 9, clsfuncoptions=clsfuncoptionstr)) if hascls: newstrs.append(automod_templ_classes.format( modname=modnm, clshds=h2 * 7, clsfuncoptions=clsfuncoptionstr)) if allowothers and hasother: newstrs.append(automod_templ_vars.format( modname=modnm, otherhds=h2 * 9, clsfuncoptions=clsfuncoptionstr)) if inhdiag and hascls: # add inheritance diagram if any classes are in the module if toskip: clsskip = ':skip: ' + ','.join(toskip) else: clsskip = '' diagram_entry = automod_templ_inh.format( modname=modnm, clsinhsechds=h2 * 25, allowedpkgnms=allowedpkgnms, skip=clsskip) diagram_entry = diagram_entry.replace(' \n', '') newstrs.append(diagram_entry) newstrs.append(spl[grp * 3 + 3]) newsourcestr = ''.join(newstrs) if app.config.automodapi_writereprocessed: # sometimes they are unicode, sometimes not, depending on how # sphinx has processed things if isinstance(newsourcestr, text_type): ustr = newsourcestr else: ustr = newsourcestr.decode(app.config.source_encoding) if docname is None: with io.open(os.path.join(app.srcdir, 'unknown.automodapi'), 'a', encoding='utf8') as f: f.write(u'\n**NEW DOC**\n\n') f.write(ustr) else: env = app.builder.env # Determine the filename associated with this doc (specifically # the extension) filename = docname + os.path.splitext(env.doc2path(docname))[1] filename += '.automodapi' with io.open(os.path.join(app.srcdir, filename), 'w', encoding='utf8') as f: f.write(ustr) return newsourcestr else: return sourcestr def _mod_info(modname, toskip=[], onlylocals=True): """ Determines if a module is a module or a package and whether or not it has classes or functions. """ hascls = hasfunc = hasother = False for localnm, fqnm, obj in zip(*find_mod_objs(modname, onlylocals=onlylocals)): if localnm not in toskip: hascls = hascls or inspect.isclass(obj) hasfunc = hasfunc or inspect.isroutine(obj) hasother = hasother or (not inspect.isclass(obj) and not inspect.isroutine(obj)) if hascls and hasfunc and hasother: break # find_mod_objs has already imported modname # TODO: There is probably a cleaner way to do this, though this is pretty # reliable for all Python versions for most cases that we care about. pkg = sys.modules[modname] ispkg = (hasattr(pkg, '__file__') and isinstance(pkg.__file__, str) and os.path.split(pkg.__file__)[1].startswith('__init__.py')) return ispkg, hascls, hasfunc, hasother def process_automodapi(app, docname, source): source[0] = automodapi_replace(source[0], app, True, docname) def setup(app): app.setup_extension('sphinx.ext.autosummary') # Note: we use __name__ here instead of just writing the module name in # case this extension is bundled into another package from . import automodsumm app.setup_extension(automodsumm.__name__) app.connect('source-read', process_automodapi) app.add_config_value('automodapi_inheritance_diagram', True, True) app.add_config_value('automodapi_toctreedirnm', 'api', True) app.add_config_value('automodapi_writereprocessed', False, True) return {'parallel_read_safe': True, 'parallel_write_safe': True} regions-0.4/astropy_helpers/astropy_helpers/extern/automodapi/automodsumm.py0000644000076600000240000006616413477530461030154 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ This directive will produce an "autosummary"-style table for public attributes of a specified module. See the `sphinx.ext.autosummary`_ extension for details on this process. The main difference from the `autosummary`_ directive is that `autosummary`_ requires manually inputting all attributes that appear in the table, while this captures the entries automatically. This directive requires a single argument that must be a module or package. It also accepts any options supported by the `autosummary`_ directive- see `sphinx.ext.autosummary`_ for details. It also accepts some additional options: * ``:classes-only:`` If present, the autosummary table will only contain entries for classes. This cannot be used at the same time with ``:functions-only:`` or ``:variables-only:``. * ``:functions-only:`` If present, the autosummary table will only contain entries for functions. This cannot be used at the same time with ``:classes-only:`` or ``:variables-only:``. * ``:variables-only:`` If present, the autosummary table will only contain entries for variables (everything except functions and classes). This cannot be used at the same time with ``:classes-only:`` or ``:functions-only:``. * ``:skip: obj1, [obj2, obj3, ...]`` If present, specifies that the listed objects should be skipped and not have their documentation generated, nor be included in the summary table. * ``:allowed-package-names: pkgormod1, [pkgormod2, pkgormod3, ...]`` Specifies the packages that functions/classes documented here are allowed to be from, as comma-separated list of package names. If not given, only objects that are actually in a subpackage of the package currently being documented are included. * ``:inherited-members:`` or ``:no-inherited-members:`` The global sphinx configuration option ``automodsumm_inherited_members`` decides if members that a class inherits from a base class are included in the generated documentation. The flags ``:inherited-members:`` or ``:no-inherited-members:`` allows overrriding this global setting. This extension also adds two sphinx configuration options: * ``automodsumm_writereprocessed`` Should be a bool, and if ``True``, will cause `automodsumm`_ to write files with any ``automodsumm`` sections replaced with the content Sphinx processes after ``automodsumm`` has run. The output files are not actually used by sphinx, so this option is only for figuring out the cause of sphinx warnings or other debugging. Defaults to ``False``. * ``automodsumm_inherited_members`` Should be a bool and if ``True``, will cause `automodsumm`_ to document class members that are inherited from a base class. This value can be overriden for any particular automodsumm directive by including the ``:inherited-members:`` or ``:no-inherited-members:`` options. Defaults to ``False``. .. _sphinx.ext.autosummary: http://sphinx-doc.org/latest/ext/autosummary.html .. _autosummary: http://sphinx-doc.org/latest/ext/autosummary.html#directive-autosummary .. _automod-diagram: automod-diagram directive ========================= This directive will produce an inheritance diagram like that of the `sphinx.ext.inheritance_diagram`_ extension. This directive requires a single argument that must be a module or package. It accepts no options. .. note:: Like 'inheritance-diagram', 'automod-diagram' requires `graphviz `_ to generate the inheritance diagram. .. _sphinx.ext.inheritance_diagram: http://sphinx-doc.org/latest/ext/inheritance.html """ import abc import inspect import os import re import io from distutils.version import LooseVersion from sphinx import __version__ from sphinx.ext.autosummary import Autosummary from sphinx.ext.inheritance_diagram import InheritanceDiagram from docutils.parsers.rst.directives import flag from .utils import find_mod_objs, cleanup_whitespace __all__ = ['Automoddiagram', 'Automodsumm', 'automodsumm_to_autosummary_lines', 'generate_automodsumm_docs', 'process_automodsumm_generation'] SPHINX_LT_16 = LooseVersion(__version__) < LooseVersion('1.6') SPHINX_LT_17 = LooseVersion(__version__) < LooseVersion('1.7') def _str_list_converter(argument): """ A directive option conversion function that converts the option into a list of strings. Used for 'skip' option. """ if argument is None: return [] else: return [s.strip() for s in argument.split(',')] class Automodsumm(Autosummary): required_arguments = 1 optional_arguments = 0 final_argument_whitespace = False has_content = False option_spec = dict(Autosummary.option_spec) option_spec['functions-only'] = flag option_spec['classes-only'] = flag option_spec['variables-only'] = flag option_spec['skip'] = _str_list_converter option_spec['allowed-package-names'] = _str_list_converter option_spec['inherited-members'] = flag option_spec['no-inherited-members'] = flag def run(self): env = self.state.document.settings.env modname = self.arguments[0] try: self.warnings[:] = [] except AttributeError: self.warnings = [] nodelist = [] try: localnames, fqns, objs = find_mod_objs(modname) except ImportError: self.warn("Couldn't import module " + modname) return self.warnings try: # set self.content to trick the autosummary internals. # Be sure to respect functions-only and classes-only. funconly = 'functions-only' in self.options clsonly = 'classes-only' in self.options varonly = 'variables-only' in self.options if [clsonly, funconly, varonly].count(True) > 1: self.warning('more than one of functions-only, classes-only, ' 'or variables-only defined. Ignoring.') clsonly = funconly = varonly = False skipnames = [] if 'skip' in self.options: option_skipnames = set(self.options['skip']) for lnm in localnames: if lnm in option_skipnames: option_skipnames.remove(lnm) skipnames.append(lnm) if len(option_skipnames) > 0: self.warn('Tried to skip objects {objs} in module {mod}, ' 'but they were not present. Ignoring.' .format(objs=option_skipnames, mod=modname)) if funconly: cont = [] for nm, obj in zip(localnames, objs): if nm not in skipnames and inspect.isroutine(obj): cont.append(nm) elif clsonly: cont = [] for nm, obj in zip(localnames, objs): if nm not in skipnames and inspect.isclass(obj): cont.append(nm) elif varonly: cont = [] for nm, obj in zip(localnames, objs): if nm not in skipnames and not (inspect.isclass(obj) or inspect.isroutine(obj)): cont.append(nm) else: cont = [nm for nm in localnames if nm not in skipnames] self.content = cont # for some reason, even though ``currentmodule`` is substituted in, # sphinx doesn't necessarily recognize this fact. So we just force # it internally, and that seems to fix things env.temp_data['py:module'] = modname env.ref_context['py:module'] = modname # can't use super because Sphinx/docutils has trouble return # super(Autosummary,self).run() nodelist.extend(Autosummary.run(self)) return self.warnings + nodelist finally: # has_content = False for the Automodsumm self.content = [] def get_items(self, names): self.genopt['imported-members'] = True return Autosummary.get_items(self, names) # <-------------------automod-diagram stuff-----------------------------------> class Automoddiagram(InheritanceDiagram): option_spec = dict(InheritanceDiagram.option_spec) option_spec['allowed-package-names'] = _str_list_converter option_spec['skip'] = _str_list_converter def run(self): try: ols = self.options.get('allowed-package-names', []) ols = True if len(ols) == 0 else ols # if none are given, assume only local nms, objs = find_mod_objs(self.arguments[0], onlylocals=ols)[1:] except ImportError: self.warnings = [] self.warn("Couldn't import module " + self.arguments[0]) return self.warnings # Check if some classes should be skipped skip = self.options.get('skip', []) clsnms = [] for n, o in zip(nms, objs): if n.split('.')[-1] in skip: continue if inspect.isclass(o): clsnms.append(n) oldargs = self.arguments try: if len(clsnms) > 0: self.arguments = [' '.join(clsnms)] return InheritanceDiagram.run(self) finally: self.arguments = oldargs # <---------------------automodsumm generation stuff--------------------------> def process_automodsumm_generation(app): env = app.builder.env filestosearch = [] for docname in env.found_docs: filename = env.doc2path(docname) if os.path.isfile(filename): filestosearch.append(docname + os.path.splitext(filename)[1]) liness = [] for sfn in filestosearch: lines = automodsumm_to_autosummary_lines(sfn, app) liness.append(lines) if app.config.automodsumm_writereprocessed: if lines: # empty list means no automodsumm entry is in the file outfn = os.path.join(app.srcdir, sfn) + '.automodsumm' with open(outfn, 'w') as f: for l in lines: f.write(l) f.write('\n') for sfn, lines in zip(filestosearch, liness): suffix = os.path.splitext(sfn)[1] if len(lines) > 0: generate_automodsumm_docs( lines, sfn, app=app, builder=app.builder, suffix=suffix, base_path=app.srcdir, inherited_members=app.config.automodsumm_inherited_members) # _automodsummrex = re.compile(r'^(\s*)\.\. automodsumm::\s*([A-Za-z0-9_.]+)\s*' # r'\n\1(\s*)(\S|$)', re.MULTILINE) _lineendrex = r'(?:\n|$)' _hdrex = r'^\n?(\s*)\.\. automodsumm::\s*(\S+)\s*' + _lineendrex _oprex1 = r'(?:\1(\s+)\S.*' + _lineendrex + ')' _oprex2 = r'(?:\1\4\S.*' + _lineendrex + ')' _automodsummrex = re.compile(_hdrex + '(' + _oprex1 + '?' + _oprex2 + '*)', re.MULTILINE) def automodsumm_to_autosummary_lines(fn, app): """ Generates lines from a file with an "automodsumm" entry suitable for feeding into "autosummary". Searches the provided file for `automodsumm` directives and returns a list of lines specifying the `autosummary` commands for the modules requested. This does *not* return the whole file contents - just an autosummary section in place of any :automodsumm: entries. Note that any options given for `automodsumm` are also included in the generated `autosummary` section. Parameters ---------- fn : str The name of the file to search for `automodsumm` entries. app : sphinx.application.Application The sphinx Application object Returns ------- lines : list of str Lines for all `automodsumm` entries with the entries replaced by `autosummary` and the module's members added. """ fullfn = os.path.join(app.builder.env.srcdir, fn) with io.open(fullfn, encoding='utf8') as fr: # Note: we use __name__ here instead of just writing the module name in # case this extension is bundled into another package from . import automodapi try: extensions = app.extensions except AttributeError: # Sphinx <1.6 extensions = app._extensions if automodapi.__name__ in extensions: # Must do the automodapi on the source to get the automodsumm # that might be in there docname = os.path.splitext(fn)[0] filestr = automodapi.automodapi_replace(fr.read(), app, True, docname, False) else: filestr = fr.read() spl = _automodsummrex.split(filestr) # 0th entry is the stuff before the first automodsumm line indent1s = spl[1::5] mods = spl[2::5] opssecs = spl[3::5] indent2s = spl[4::5] remainders = spl[5::5] # only grab automodsumm sections and convert them to autosummary with the # entries for all the public objects newlines = [] # loop over all automodsumms in this document for i, (i1, i2, modnm, ops, rem) in enumerate(zip(indent1s, indent2s, mods, opssecs, remainders)): allindent = i1 + (' ' if i2 is None else i2) # filter out functions-only, classes-only, and ariables-only # options if present. oplines = ops.split('\n') toskip = [] allowedpkgnms = [] funcsonly = clssonly = varsonly = False for i, ln in reversed(list(enumerate(oplines))): if ':functions-only:' in ln: funcsonly = True del oplines[i] if ':classes-only:' in ln: clssonly = True del oplines[i] if ':variables-only:' in ln: varsonly = True del oplines[i] if ':skip:' in ln: toskip.extend(_str_list_converter(ln.replace(':skip:', ''))) del oplines[i] if ':allowed-package-names:' in ln: allowedpkgnms.extend(_str_list_converter(ln.replace(':allowed-package-names:', ''))) del oplines[i] if [funcsonly, clssonly, varsonly].count(True) > 1: msg = ('Defined more than one of functions-only, classes-only, ' 'and variables-only. Skipping this directive.') lnnum = sum([spl[j].count('\n') for j in range(i * 5 + 1)]) app.warn('[automodsumm]' + msg, (fn, lnnum)) continue # Use the currentmodule directive so we can just put the local names # in the autosummary table. Note that this doesn't always seem to # actually "take" in Sphinx's eyes, so in `Automodsumm.run`, we have to # force it internally, as well. newlines.extend([i1 + '.. currentmodule:: ' + modnm, '', '.. autosummary::']) newlines.extend(oplines) ols = True if len(allowedpkgnms) == 0 else allowedpkgnms for nm, fqn, obj in zip(*find_mod_objs(modnm, onlylocals=ols)): if nm in toskip: continue if funcsonly and not inspect.isroutine(obj): continue if clssonly and not inspect.isclass(obj): continue if varsonly and (inspect.isclass(obj) or inspect.isroutine(obj)): continue newlines.append(allindent + nm) # add one newline at the end of the autosummary block newlines.append('') return newlines def generate_automodsumm_docs(lines, srcfn, app=None, suffix='.rst', base_path=None, builder=None, template_dir=None, inherited_members=False): """ This function is adapted from `sphinx.ext.autosummary.generate.generate_autosummmary_docs` to generate source for the automodsumm directives that should be autosummarized. Unlike generate_autosummary_docs, this function is called one file at a time. """ from sphinx.jinja2glue import BuiltinTemplateLoader from sphinx.ext.autosummary import import_by_name, get_documenter from sphinx.util.osutil import ensuredir from sphinx.util.inspect import safe_getattr from jinja2 import FileSystemLoader, TemplateNotFound from jinja2.sandbox import SandboxedEnvironment from .utils import find_autosummary_in_lines_for_automodsumm as find_autosummary_in_lines if SPHINX_LT_16: info = app.info warn = app.warn else: from sphinx.util import logging logger = logging.getLogger(__name__) info = logger.info warn = logger.warning # info('[automodsumm] generating automodsumm for: ' + srcfn) # Create our own templating environment - here we use Astropy's # templates rather than the default autosummary templates, in order to # allow docstrings to be shown for methods. template_dirs = [os.path.join(os.path.dirname(__file__), 'templates'), os.path.join(base_path, '_templates')] if builder is not None: # allow the user to override the templates template_loader = BuiltinTemplateLoader() template_loader.init(builder, dirs=template_dirs) else: if template_dir: template_dirs.insert(0, template_dir) template_loader = FileSystemLoader(template_dirs) template_env = SandboxedEnvironment(loader=template_loader) # read # items = find_autosummary_in_files(sources) items = find_autosummary_in_lines(lines, filename=srcfn) if len(items) > 0: msg = '[automodsumm] {1}: found {0} automodsumm entries to generate' info(msg.format(len(items), srcfn)) # gennms = [item[0] for item in items] # if len(gennms) > 20: # gennms = gennms[:10] + ['...'] + gennms[-10:] # info('[automodsumm] generating autosummary for: ' + ', '.join(gennms)) # remove possible duplicates items = list(set(items)) # keep track of new files new_files = [] # write for name, path, template_name, inherited_mem in sorted(items): if path is None: # The corresponding autosummary:: directive did not have # a :toctree: option continue path = os.path.abspath(os.path.join(base_path, path)) ensuredir(path) try: import_by_name_values = import_by_name(name) except ImportError as e: warn('[automodsumm] failed to import %r: %s' % (name, e)) continue # if block to accommodate Sphinx's v1.2.2 and v1.2.3 respectively if len(import_by_name_values) == 3: name, obj, parent = import_by_name_values elif len(import_by_name_values) == 4: name, obj, parent, module_name = import_by_name_values fn = os.path.join(path, name + suffix) # skip it if it exists if os.path.isfile(fn): continue new_files.append(fn) f = open(fn, 'w') try: if SPHINX_LT_17: doc = get_documenter(obj, parent) else: doc = get_documenter(app, obj, parent) if template_name is not None: template = template_env.get_template(template_name) else: tmplstr = 'autosummary_core/%s.rst' try: template = template_env.get_template(tmplstr % doc.objtype) except TemplateNotFound: template = template_env.get_template(tmplstr % 'base') def get_members_mod(obj, typ, include_public=[]): """ typ = None -> all """ items = [] for name in dir(obj): try: if SPHINX_LT_17: documenter = get_documenter(safe_getattr(obj, name), obj) else: documenter = get_documenter(app, safe_getattr(obj, name), obj) except AttributeError: continue if typ is None or documenter.objtype == typ: items.append(name) public = [x for x in items if x in include_public or not x.startswith('_')] return public, items def get_members_class(obj, typ, include_public=[], include_base=False): """ typ = None -> all include_base -> include attrs that are from a base class """ items = [] # using dir gets all of the attributes, including the elements # from the base class, otherwise use __slots__ or __dict__ if include_base: names = dir(obj) else: # Classes deriving from an ABC using the `abc` module will # have an empty `__slots__` attribute in Python 3, unless # other slots were declared along the inheritance chain. If # the ABC-derived class has empty slots, we'll use the # class `__dict__` instead. declares_slots = ( hasattr(obj, '__slots__') and not (type(obj) is abc.ABCMeta and len(obj.__slots__) == 0) ) if declares_slots: names = tuple(getattr(obj, '__slots__')) else: names = getattr(obj, '__dict__').keys() for name in names: try: if SPHINX_LT_17: documenter = get_documenter(safe_getattr(obj, name), obj) else: documenter = get_documenter(app, safe_getattr(obj, name), obj) except AttributeError: continue if typ is None or documenter.objtype == typ: items.append(name) elif typ == 'attribute' and documenter.objtype == 'property': # In Sphinx 2.0 and above, properties have a separate # objtype, but we treat them the same here. items.append(name) public = [x for x in items if x in include_public or not x.startswith('_')] return public, items ns = {} if doc.objtype == 'module': ns['members'] = get_members_mod(obj, None) ns['functions'], ns['all_functions'] = \ get_members_mod(obj, 'function') ns['classes'], ns['all_classes'] = \ get_members_mod(obj, 'class') ns['exceptions'], ns['all_exceptions'] = \ get_members_mod(obj, 'exception') elif doc.objtype == 'class': if inherited_mem is not None: # option set in this specifc directive include_base = inherited_mem else: # use default value include_base = inherited_members api_class_methods = ['__init__', '__call__'] ns['members'] = get_members_class(obj, None, include_base=include_base) ns['methods'], ns['all_methods'] = \ get_members_class(obj, 'method', api_class_methods, include_base=include_base) ns['attributes'], ns['all_attributes'] = \ get_members_class(obj, 'attribute', include_base=include_base) ns['methods'].sort() ns['attributes'].sort() parts = name.split('.') if doc.objtype in ('method', 'attribute'): mod_name = '.'.join(parts[:-2]) cls_name = parts[-2] obj_name = '.'.join(parts[-2:]) ns['class'] = cls_name else: mod_name, obj_name = '.'.join(parts[:-1]), parts[-1] ns['fullname'] = name ns['module'] = mod_name ns['objname'] = obj_name ns['name'] = parts[-1] ns['objtype'] = doc.objtype ns['underline'] = len(obj_name) * '=' # We now check whether a file for reference footnotes exists for # the module being documented. We first check if the # current module is a file or a directory, as this will give a # different path for the reference file. For example, if # documenting astropy.wcs then the reference file is at # ../wcs/references.txt, while if we are documenting # astropy.config.logging_helper (which is at # astropy/config/logging_helper.py) then the reference file is set # to ../config/references.txt if '.' in mod_name: mod_name_dir = mod_name.split('.', 1)[1].replace('.', os.sep) else: mod_name_dir = mod_name if (not os.path.isdir(os.path.join(base_path, mod_name_dir)) and os.path.isdir(os.path.join(base_path, mod_name_dir.rsplit(os.sep, 1)[0]))): mod_name_dir = mod_name_dir.rsplit(os.sep, 1)[0] # We then have to check whether it exists, and if so, we pass it # to the template. if os.path.exists(os.path.join(base_path, mod_name_dir, 'references.txt')): # An important subtlety here is that the path we pass in has # to be relative to the file being generated, so we have to # figure out the right number of '..'s ndirsback = path.replace(base_path, '').count(os.sep) ref_file_rel_segments = ['..'] * ndirsback ref_file_rel_segments.append(mod_name_dir) ref_file_rel_segments.append('references.txt') ns['referencefile'] = os.path.join(*ref_file_rel_segments).replace(os.sep, '/') rendered = template.render(**ns) f.write(cleanup_whitespace(rendered)) finally: f.close() def setup(app): # need autodoc fixes # Note: we use __name__ here instead of just writing the module name in # case this extension is bundled into another package from . import autodoc_enhancements app.setup_extension(autodoc_enhancements.__name__) # need inheritance-diagram for automod-diagram app.setup_extension('sphinx.ext.inheritance_diagram') app.add_directive('automod-diagram', Automoddiagram) app.add_directive('automodsumm', Automodsumm) app.connect('builder-inited', process_automodsumm_generation) app.add_config_value('automodsumm_writereprocessed', False, True) app.add_config_value('automodsumm_inherited_members', False, 'env') return {'parallel_read_safe': True, 'parallel_write_safe': True} regions-0.4/astropy_helpers/astropy_helpers/extern/automodapi/smart_resolver.py0000644000076600000240000001006413477530461030635 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ The classes in the astropy docs are documented by their API location, which is not necessarily where they are defined in the source. This causes a problem when certain automated features of the doc build, such as the inheritance diagrams or the `Bases` list of a class reference a class by its canonical location rather than its "user" location. In the `autodoc-process-docstring` event, a mapping from the actual name to the API name is maintained. Later, in the `missing-reference` event, unresolved references are looked up in this dictionary and corrected if possible. """ from docutils.nodes import literal, reference def process_docstring(app, what, name, obj, options, lines): if isinstance(obj, type): env = app.env if not hasattr(env, 'class_name_mapping'): env.class_name_mapping = {} mapping = env.class_name_mapping mapping[obj.__module__ + '.' + obj.__name__] = name def merge_mapping(app, env, docnames, env_other): if not hasattr(env_other, 'class_name_mapping'): return if not hasattr(env, 'class_name_mapping'): env.class_name_mapping = {} env.class_name_mapping.update(env_other.class_name_mapping) def missing_reference_handler(app, env, node, contnode): if not hasattr(env, 'class_name_mapping'): env.class_name_mapping = {} mapping = env.class_name_mapping reftype = node['reftype'] reftarget = node['reftarget'] if reftype in ('obj', 'class', 'exc', 'meth'): reftarget = node['reftarget'] suffix = '' if reftarget not in mapping: if '.' in reftarget: front, suffix = reftarget.rsplit('.', 1) else: suffix = reftarget if suffix.startswith('_') and not suffix.startswith('__'): # If this is a reference to a hidden class or method, # we can't link to it, but we don't want to have a # nitpick warning. return node[0].deepcopy() if reftype in ('obj', 'meth') and '.' in reftarget: if front in mapping: reftarget = front suffix = '.' + suffix if (reftype in ('class', ) and '.' in reftarget and reftarget not in mapping): if '.' in front: reftarget, _ = front.rsplit('.', 1) suffix = '.' + suffix reftarget = reftarget + suffix prefix = reftarget.rsplit('.')[0] inventory = env.intersphinx_named_inventory if (reftarget not in mapping and prefix in inventory): if 'py:class' in inventory[prefix] and reftarget in inventory[prefix]['py:class']: newtarget = inventory[prefix]['py:class'][reftarget][2] if not node['refexplicit'] and \ '~' not in node.rawsource: contnode = literal(text=reftarget) newnode = reference('', '', internal=True) newnode['reftitle'] = reftarget newnode['refuri'] = newtarget newnode.append(contnode) return newnode if reftarget in mapping: newtarget = mapping[reftarget] + suffix if not node['refexplicit'] and '~' not in node.rawsource: contnode = literal(text=newtarget) newnode = env.domains['py'].resolve_xref( env, node['refdoc'], app.builder, 'class', newtarget, node, contnode) if newnode is not None: newnode['reftitle'] = reftarget return newnode def setup(app): app.connect('autodoc-process-docstring', process_docstring) app.connect('missing-reference', missing_reference_handler) app.connect('env-merge-info', merge_mapping) return {'parallel_read_safe': True, 'parallel_write_safe': True} regions-0.4/astropy_helpers/astropy_helpers/extern/automodapi/templates/0000755000076600000240000000000013501657425027207 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/extern/automodapi/templates/autosummary_core/0000755000076600000240000000000013501657425032605 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/extern/automodapi/templates/autosummary_core/base.rst0000644000076600000240000000025213336766207034255 0ustar deilstaff00000000000000{% if referencefile %} .. include:: {{ referencefile }} {% endif %} {{ objname }} {{ underline }} .. currentmodule:: {{ module }} .. auto{{ objtype }}:: {{ objname }} regions-0.4/astropy_helpers/astropy_helpers/extern/automodapi/templates/autosummary_core/class.rst0000644000076600000240000000221113336766207034445 0ustar deilstaff00000000000000{% if referencefile %} .. include:: {{ referencefile }} {% endif %} {{ objname }} {{ underline }} .. currentmodule:: {{ module }} .. autoclass:: {{ objname }} :show-inheritance: {% if '__init__' in methods %} {% set caught_result = methods.remove('__init__') %} {% endif %} {% block attributes_summary %} {% if attributes %} .. rubric:: Attributes Summary .. autosummary:: {% for item in attributes %} ~{{ name }}.{{ item }} {%- endfor %} {% endif %} {% endblock %} {% block methods_summary %} {% if methods %} .. rubric:: Methods Summary .. autosummary:: {% for item in methods %} ~{{ name }}.{{ item }} {%- endfor %} {% endif %} {% endblock %} {% block attributes_documentation %} {% if attributes %} .. rubric:: Attributes Documentation {% for item in attributes %} .. autoattribute:: {{ item }} {%- endfor %} {% endif %} {% endblock %} {% block methods_documentation %} {% if methods %} .. rubric:: Methods Documentation {% for item in methods %} .. automethod:: {{ item }} {%- endfor %} {% endif %} {% endblock %} regions-0.4/astropy_helpers/astropy_helpers/extern/automodapi/templates/autosummary_core/module.rst0000644000076600000240000000127713336766207034640 0ustar deilstaff00000000000000{% if referencefile %} .. include:: {{ referencefile }} {% endif %} {{ objname }} {{ underline }} .. automodule:: {{ fullname }} {% block functions %} {% if functions %} .. rubric:: Functions .. autosummary:: {% for item in functions %} {{ item }} {%- endfor %} {% endif %} {% endblock %} {% block classes %} {% if classes %} .. rubric:: Classes .. autosummary:: {% for item in classes %} {{ item }} {%- endfor %} {% endif %} {% endblock %} {% block exceptions %} {% if exceptions %} .. rubric:: Exceptions .. autosummary:: {% for item in exceptions %} {{ item }} {%- endfor %} {% endif %} {% endblock %} regions-0.4/astropy_helpers/astropy_helpers/extern/automodapi/utils.py0000644000076600000240000001574413336766207026743 0ustar deilstaff00000000000000import inspect import sys import re import os from warnings import warn from sphinx.ext.autosummary.generate import find_autosummary_in_docstring if sys.version_info[0] >= 3: def iteritems(dictionary): return dictionary.items() else: def iteritems(dictionary): return dictionary.iteritems() # We use \n instead of os.linesep because even on Windows, the generated files # use \n as the newline character. SPACE_NEWLINE = ' \n' SINGLE_NEWLINE = '\n' DOUBLE_NEWLINE = '\n\n' TRIPLE_NEWLINE = '\n\n\n' def cleanup_whitespace(text): """ Make sure there are never more than two consecutive newlines, and that there are no trailing whitespaces. """ # Get rid of overall leading/trailing whitespace text = text.strip() + '\n' # Get rid of trailing whitespace on each line while SPACE_NEWLINE in text: text = text.replace(SPACE_NEWLINE, SINGLE_NEWLINE) # Avoid too many consecutive newlines while TRIPLE_NEWLINE in text: text = text.replace(TRIPLE_NEWLINE, DOUBLE_NEWLINE) return text def find_mod_objs(modname, onlylocals=False): """ Returns all the public attributes of a module referenced by name. .. note:: The returned list *not* include subpackages or modules of `modname`,nor does it include private attributes (those that beginwith '_' or are not in `__all__`). Parameters ---------- modname : str The name of the module to search. onlylocals : bool If True, only attributes that are either members of `modname` OR one of its modules or subpackages will be included. Returns ------- localnames : list of str A list of the names of the attributes as they are named in the module `modname` . fqnames : list of str A list of the full qualified names of the attributes (e.g., ``astropy.utils.misc.find_mod_objs``). For attributes that are simple variables, this is based on the local name, but for functions or classes it can be different if they are actually defined elsewhere and just referenced in `modname`. objs : list of objects A list of the actual attributes themselves (in the same order as the other arguments) """ __import__(modname) mod = sys.modules[modname] if hasattr(mod, '__all__'): pkgitems = [(k, mod.__dict__[k]) for k in mod.__all__] else: pkgitems = [(k, mod.__dict__[k]) for k in dir(mod) if k[0] != '_'] # filter out modules and pull the names and objs out ismodule = inspect.ismodule localnames = [k for k, v in pkgitems if not ismodule(v)] objs = [v for k, v in pkgitems if not ismodule(v)] # fully qualified names can be determined from the object's module fqnames = [] for obj, lnm in zip(objs, localnames): if hasattr(obj, '__module__') and hasattr(obj, '__name__'): fqnames.append(obj.__module__ + '.' + obj.__name__) else: fqnames.append(modname + '.' + lnm) if onlylocals: valids = [fqn.startswith(modname) for fqn in fqnames] localnames = [e for i, e in enumerate(localnames) if valids[i]] fqnames = [e for i, e in enumerate(fqnames) if valids[i]] objs = [e for i, e in enumerate(objs) if valids[i]] return localnames, fqnames, objs def find_autosummary_in_lines_for_automodsumm(lines, module=None, filename=None): """Find out what items appear in autosummary:: directives in the given lines. Returns a list of (name, toctree, template, inherited_members) where *name* is a name of an object and *toctree* the :toctree: path of the corresponding autosummary directive (relative to the root of the file name), *template* the value of the :template: option, and *inherited_members* is the value of the :inherited-members: option. *toctree*, *template*, and *inherited_members* are ``None`` if the directive does not have the corresponding options set. .. note:: This is a slightly modified version of ``sphinx.ext.autosummary.generate.find_autosummary_in_lines`` which recognizes the ``inherited-members`` option. """ autosummary_re = re.compile(r'^(\s*)\.\.\s+autosummary::\s*') automodule_re = re.compile( r'^\s*\.\.\s+automodule::\s*([A-Za-z0-9_.]+)\s*$') module_re = re.compile( r'^\s*\.\.\s+(current)?module::\s*([a-zA-Z0-9_.]+)\s*$') autosummary_item_re = re.compile(r'^\s+(~?[_a-zA-Z][a-zA-Z0-9_.]*)\s*.*?') toctree_arg_re = re.compile(r'^\s+:toctree:\s*(.*?)\s*$') template_arg_re = re.compile(r'^\s+:template:\s*(.*?)\s*$') inherited_members_arg_re = re.compile(r'^\s+:inherited-members:\s*$') no_inherited_members_arg_re = re.compile(r'^\s+:no-inherited-members:\s*$') documented = [] toctree = None template = None inherited_members = None current_module = module in_autosummary = False base_indent = "" for line in lines: if in_autosummary: m = toctree_arg_re.match(line) if m: toctree = m.group(1) if filename: toctree = os.path.join(os.path.dirname(filename), toctree) continue m = template_arg_re.match(line) if m: template = m.group(1).strip() continue m = inherited_members_arg_re.match(line) if m: inherited_members = True continue m = no_inherited_members_arg_re.match(line) if m: inherited_members = False continue if line.strip().startswith(':'): warn(line) continue # skip options m = autosummary_item_re.match(line) if m: name = m.group(1).strip() if name.startswith('~'): name = name[1:] if current_module and \ not name.startswith(current_module + '.'): name = "%s.%s" % (current_module, name) documented.append((name, toctree, template, inherited_members)) continue if not line.strip() or line.startswith(base_indent + " "): continue in_autosummary = False m = autosummary_re.match(line) if m: in_autosummary = True base_indent = m.group(1) toctree = None template = None inherited_members = None continue m = automodule_re.search(line) if m: current_module = m.group(1).strip() # recurse into the automodule docstring documented.extend(find_autosummary_in_docstring( current_module, filename=filename)) continue m = module_re.match(line) if m: current_module = m.group(2) continue return documented regions-0.4/astropy_helpers/astropy_helpers/extern/numpydoc/0000755000076600000240000000000013501657425024705 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/extern/numpydoc/__init__.py0000644000076600000240000000030213467311012026777 0ustar deilstaff00000000000000from __future__ import division, absolute_import, print_function __version__ = '0.8.0' def setup(app, *args, **kwargs): from .numpydoc import setup return setup(app, *args, **kwargs) regions-0.4/astropy_helpers/astropy_helpers/extern/numpydoc/docscrape.py0000644000076600000240000004540613467311012027221 0ustar deilstaff00000000000000"""Extract reference documentation from the NumPy source tree. """ from __future__ import division, absolute_import, print_function import inspect import textwrap import re import pydoc from warnings import warn import collections import copy import sys def strip_blank_lines(l): "Remove leading and trailing blank lines from a list of lines" while l and not l[0].strip(): del l[0] while l and not l[-1].strip(): del l[-1] return l class Reader(object): """A line-based string reader. """ def __init__(self, data): """ Parameters ---------- data : str String with lines separated by '\n'. """ if isinstance(data, list): self._str = data else: self._str = data.split('\n') # store string as list of lines self.reset() def __getitem__(self, n): return self._str[n] def reset(self): self._l = 0 # current line nr def read(self): if not self.eof(): out = self[self._l] self._l += 1 return out else: return '' def seek_next_non_empty_line(self): for l in self[self._l:]: if l.strip(): break else: self._l += 1 def eof(self): return self._l >= len(self._str) def read_to_condition(self, condition_func): start = self._l for line in self[start:]: if condition_func(line): return self[start:self._l] self._l += 1 if self.eof(): return self[start:self._l+1] return [] def read_to_next_empty_line(self): self.seek_next_non_empty_line() def is_empty(line): return not line.strip() return self.read_to_condition(is_empty) def read_to_next_unindented_line(self): def is_unindented(line): return (line.strip() and (len(line.lstrip()) == len(line))) return self.read_to_condition(is_unindented) def peek(self, n=0): if self._l + n < len(self._str): return self[self._l + n] else: return '' def is_empty(self): return not ''.join(self._str).strip() class ParseError(Exception): def __str__(self): message = self.args[0] if hasattr(self, 'docstring'): message = "%s in %r" % (message, self.docstring) return message class NumpyDocString(collections.Mapping): """Parses a numpydoc string to an abstract representation Instances define a mapping from section title to structured data. """ sections = { 'Signature': '', 'Summary': [''], 'Extended Summary': [], 'Parameters': [], 'Returns': [], 'Yields': [], 'Raises': [], 'Warns': [], 'Other Parameters': [], 'Attributes': [], 'Methods': [], 'See Also': [], 'Notes': [], 'Warnings': [], 'References': '', 'Examples': '', 'index': {} } def __init__(self, docstring, config={}): orig_docstring = docstring docstring = textwrap.dedent(docstring).split('\n') self._doc = Reader(docstring) self._parsed_data = copy.deepcopy(self.sections) try: self._parse() except ParseError as e: e.docstring = orig_docstring raise def __getitem__(self, key): return self._parsed_data[key] def __setitem__(self, key, val): if key not in self._parsed_data: self._error_location("Unknown section %s" % key, error=False) else: self._parsed_data[key] = val def __iter__(self): return iter(self._parsed_data) def __len__(self): return len(self._parsed_data) def _is_at_section(self): self._doc.seek_next_non_empty_line() if self._doc.eof(): return False l1 = self._doc.peek().strip() # e.g. Parameters if l1.startswith('.. index::'): return True l2 = self._doc.peek(1).strip() # ---------- or ========== return l2.startswith('-'*len(l1)) or l2.startswith('='*len(l1)) def _strip(self, doc): i = 0 j = 0 for i, line in enumerate(doc): if line.strip(): break for j, line in enumerate(doc[::-1]): if line.strip(): break return doc[i:len(doc)-j] def _read_to_next_section(self): section = self._doc.read_to_next_empty_line() while not self._is_at_section() and not self._doc.eof(): if not self._doc.peek(-1).strip(): # previous line was empty section += [''] section += self._doc.read_to_next_empty_line() return section def _read_sections(self): while not self._doc.eof(): data = self._read_to_next_section() name = data[0].strip() if name.startswith('..'): # index section yield name, data[1:] elif len(data) < 2: yield StopIteration else: yield name, self._strip(data[2:]) def _parse_param_list(self, content): r = Reader(content) params = [] while not r.eof(): header = r.read().strip() if ' : ' in header: arg_name, arg_type = header.split(' : ')[:2] else: arg_name, arg_type = header, '' desc = r.read_to_next_unindented_line() desc = dedent_lines(desc) desc = strip_blank_lines(desc) params.append((arg_name, arg_type, desc)) return params _name_rgx = re.compile(r"^\s*(:(?P\w+):" r"`(?P(?:~\w+\.)?[a-zA-Z0-9_.-]+)`|" r" (?P[a-zA-Z0-9_.-]+))\s*", re.X) def _parse_see_also(self, content): """ func_name : Descriptive text continued text another_func_name : Descriptive text func_name1, func_name2, :meth:`func_name`, func_name3 """ items = [] def parse_item_name(text): """Match ':role:`name`' or 'name'""" m = self._name_rgx.match(text) if m: g = m.groups() if g[1] is None: return g[3], None else: return g[2], g[1] raise ParseError("%s is not a item name" % text) def push_item(name, rest): if not name: return name, role = parse_item_name(name) items.append((name, list(rest), role)) del rest[:] current_func = None rest = [] for line in content: if not line.strip(): continue m = self._name_rgx.match(line) if m and line[m.end():].strip().startswith(':'): push_item(current_func, rest) current_func, line = line[:m.end()], line[m.end():] rest = [line.split(':', 1)[1].strip()] if not rest[0]: rest = [] elif not line.startswith(' '): push_item(current_func, rest) current_func = None if ',' in line: for func in line.split(','): if func.strip(): push_item(func, []) elif line.strip(): current_func = line elif current_func is not None: rest.append(line.strip()) push_item(current_func, rest) return items def _parse_index(self, section, content): """ .. index: default :refguide: something, else, and more """ def strip_each_in(lst): return [s.strip() for s in lst] out = {} section = section.split('::') if len(section) > 1: out['default'] = strip_each_in(section[1].split(','))[0] for line in content: line = line.split(':') if len(line) > 2: out[line[1]] = strip_each_in(line[2].split(',')) return out def _parse_summary(self): """Grab signature (if given) and summary""" if self._is_at_section(): return # If several signatures present, take the last one while True: summary = self._doc.read_to_next_empty_line() summary_str = " ".join([s.strip() for s in summary]).strip() if re.compile('^([\w., ]+=)?\s*[\w\.]+\(.*\)$').match(summary_str): self['Signature'] = summary_str if not self._is_at_section(): continue break if summary is not None: self['Summary'] = summary if not self._is_at_section(): self['Extended Summary'] = self._read_to_next_section() def _parse(self): self._doc.reset() self._parse_summary() sections = list(self._read_sections()) section_names = set([section for section, content in sections]) has_returns = 'Returns' in section_names has_yields = 'Yields' in section_names # We could do more tests, but we are not. Arbitrarily. if has_returns and has_yields: msg = 'Docstring contains both a Returns and Yields section.' raise ValueError(msg) for (section, content) in sections: if not section.startswith('..'): section = (s.capitalize() for s in section.split(' ')) section = ' '.join(section) if self.get(section): self._error_location("The section %s appears twice" % section) if section in ('Parameters', 'Returns', 'Yields', 'Raises', 'Warns', 'Other Parameters', 'Attributes', 'Methods'): self[section] = self._parse_param_list(content) elif section.startswith('.. index::'): self['index'] = self._parse_index(section, content) elif section == 'See Also': self['See Also'] = self._parse_see_also(content) else: self[section] = content def _error_location(self, msg, error=True): if hasattr(self, '_obj'): # we know where the docs came from: try: filename = inspect.getsourcefile(self._obj) except TypeError: filename = None msg = msg + (" in the docstring of %s in %s." % (self._obj, filename)) if error: raise ValueError(msg) else: warn(msg) # string conversion routines def _str_header(self, name, symbol='-'): return [name, len(name)*symbol] def _str_indent(self, doc, indent=4): out = [] for line in doc: out += [' '*indent + line] return out def _str_signature(self): if self['Signature']: return [self['Signature'].replace('*', '\*')] + [''] else: return [''] def _str_summary(self): if self['Summary']: return self['Summary'] + [''] else: return [] def _str_extended_summary(self): if self['Extended Summary']: return self['Extended Summary'] + [''] else: return [] def _str_param_list(self, name): out = [] if self[name]: out += self._str_header(name) for param, param_type, desc in self[name]: if param_type: out += ['%s : %s' % (param, param_type)] else: out += [param] if desc and ''.join(desc).strip(): out += self._str_indent(desc) out += [''] return out def _str_section(self, name): out = [] if self[name]: out += self._str_header(name) out += self[name] out += [''] return out def _str_see_also(self, func_role): if not self['See Also']: return [] out = [] out += self._str_header("See Also") last_had_desc = True for func, desc, role in self['See Also']: if role: link = ':%s:`%s`' % (role, func) elif func_role: link = ':%s:`%s`' % (func_role, func) else: link = "`%s`_" % func if desc or last_had_desc: out += [''] out += [link] else: out[-1] += ", %s" % link if desc: out += self._str_indent([' '.join(desc)]) last_had_desc = True else: last_had_desc = False out += [''] return out def _str_index(self): idx = self['index'] out = [] out += ['.. index:: %s' % idx.get('default', '')] for section, references in idx.items(): if section == 'default': continue out += [' :%s: %s' % (section, ', '.join(references))] return out def __str__(self, func_role=''): out = [] out += self._str_signature() out += self._str_summary() out += self._str_extended_summary() for param_list in ('Parameters', 'Returns', 'Yields', 'Other Parameters', 'Raises', 'Warns'): out += self._str_param_list(param_list) out += self._str_section('Warnings') out += self._str_see_also(func_role) for s in ('Notes', 'References', 'Examples'): out += self._str_section(s) for param_list in ('Attributes', 'Methods'): out += self._str_param_list(param_list) out += self._str_index() return '\n'.join(out) def indent(str, indent=4): indent_str = ' '*indent if str is None: return indent_str lines = str.split('\n') return '\n'.join(indent_str + l for l in lines) def dedent_lines(lines): """Deindent a list of lines maximally""" return textwrap.dedent("\n".join(lines)).split("\n") def header(text, style='-'): return text + '\n' + style*len(text) + '\n' class FunctionDoc(NumpyDocString): def __init__(self, func, role='func', doc=None, config={}): self._f = func self._role = role # e.g. "func" or "meth" if doc is None: if func is None: raise ValueError("No function or docstring given") doc = inspect.getdoc(func) or '' NumpyDocString.__init__(self, doc) if not self['Signature'] and func is not None: func, func_name = self.get_func() try: try: signature = str(inspect.signature(func)) except (AttributeError, ValueError): # try to read signature, backward compat for older Python if sys.version_info[0] >= 3: argspec = inspect.getfullargspec(func) else: argspec = inspect.getargspec(func) signature = inspect.formatargspec(*argspec) signature = '%s%s' % (func_name, signature.replace('*', '\*')) except TypeError: signature = '%s()' % func_name self['Signature'] = signature def get_func(self): func_name = getattr(self._f, '__name__', self.__class__.__name__) if inspect.isclass(self._f): func = getattr(self._f, '__call__', self._f.__init__) else: func = self._f return func, func_name def __str__(self): out = '' func, func_name = self.get_func() signature = self['Signature'].replace('*', '\*') roles = {'func': 'function', 'meth': 'method'} if self._role: if self._role not in roles: print("Warning: invalid role %s" % self._role) out += '.. %s:: %s\n \n\n' % (roles.get(self._role, ''), func_name) out += super(FunctionDoc, self).__str__(func_role=self._role) return out class ClassDoc(NumpyDocString): extra_public_methods = ['__call__'] def __init__(self, cls, doc=None, modulename='', func_doc=FunctionDoc, config={}): if not inspect.isclass(cls) and cls is not None: raise ValueError("Expected a class or None, but got %r" % cls) self._cls = cls self.show_inherited_members = config.get( 'show_inherited_class_members', True) if modulename and not modulename.endswith('.'): modulename += '.' self._mod = modulename if doc is None: if cls is None: raise ValueError("No class or documentation string given") doc = pydoc.getdoc(cls) NumpyDocString.__init__(self, doc) if config.get('show_class_members', True): def splitlines_x(s): if not s: return [] else: return s.splitlines() for field, items in [('Methods', self.methods), ('Attributes', self.properties)]: if not self[field]: doc_list = [] for name in sorted(items): try: doc_item = pydoc.getdoc(getattr(self._cls, name)) doc_list.append((name, '', splitlines_x(doc_item))) except AttributeError: pass # method doesn't exist self[field] = doc_list @property def methods(self): if self._cls is None: return [] return [name for name, func in inspect.getmembers(self._cls) if ((not name.startswith('_') or name in self.extra_public_methods) and isinstance(func, collections.Callable) and self._is_show_member(name))] @property def properties(self): if self._cls is None: return [] return [name for name, func in inspect.getmembers(self._cls) if (not name.startswith('_') and (func is None or isinstance(func, property) or inspect.isdatadescriptor(func)) and self._is_show_member(name))] def _is_show_member(self, name): if self.show_inherited_members: return True # show all class members if name not in self._cls.__dict__: return False # class member is inherited, we do not show it return True regions-0.4/astropy_helpers/astropy_helpers/extern/numpydoc/docscrape_sphinx.py0000644000076600000240000003547013467311012030612 0ustar deilstaff00000000000000from __future__ import division, absolute_import, print_function import sys import re import inspect import textwrap import pydoc import collections import os from jinja2 import FileSystemLoader from jinja2.sandbox import SandboxedEnvironment import sphinx from sphinx.jinja2glue import BuiltinTemplateLoader from .docscrape import NumpyDocString, FunctionDoc, ClassDoc if sys.version_info[0] >= 3: sixu = lambda s: s else: sixu = lambda s: unicode(s, 'unicode_escape') IMPORT_MATPLOTLIB_RE = r'\b(import +matplotlib|from +matplotlib +import)\b' class SphinxDocString(NumpyDocString): def __init__(self, docstring, config={}): NumpyDocString.__init__(self, docstring, config=config) self.load_config(config) def load_config(self, config): self.use_plots = config.get('use_plots', False) self.use_blockquotes = config.get('use_blockquotes', False) self.class_members_toctree = config.get('class_members_toctree', True) self.template = config.get('template', None) if self.template is None: template_dirs = [os.path.join(os.path.dirname(__file__), 'templates')] template_loader = FileSystemLoader(template_dirs) template_env = SandboxedEnvironment(loader=template_loader) self.template = template_env.get_template('numpydoc_docstring.rst') # string conversion routines def _str_header(self, name, symbol='`'): return ['.. rubric:: ' + name, ''] def _str_field_list(self, name): return [':' + name + ':'] def _str_indent(self, doc, indent=4): out = [] for line in doc: out += [' '*indent + line] return out def _str_signature(self): return [''] if self['Signature']: return ['``%s``' % self['Signature']] + [''] else: return [''] def _str_summary(self): return self['Summary'] + [''] def _str_extended_summary(self): return self['Extended Summary'] + [''] def _str_returns(self, name='Returns'): typed_fmt = '**%s** : %s' untyped_fmt = '**%s**' out = [] if self[name]: out += self._str_field_list(name) out += [''] for param, param_type, desc in self[name]: if param_type: out += self._str_indent([typed_fmt % (param.strip(), param_type)]) else: out += self._str_indent([untyped_fmt % param.strip()]) if desc and self.use_blockquotes: out += [''] elif not desc: desc = ['..'] out += self._str_indent(desc, 8) out += [''] return out def _process_param(self, param, desc, fake_autosummary): """Determine how to display a parameter Emulates autosummary behavior if fake_autosummary Parameters ---------- param : str The name of the parameter desc : list of str The parameter description as given in the docstring. This is ignored when autosummary logic applies. fake_autosummary : bool If True, autosummary-style behaviour will apply for params that are attributes of the class and have a docstring. Returns ------- display_param : str The marked up parameter name for display. This may include a link to the corresponding attribute's own documentation. desc : list of str A list of description lines. This may be identical to the input ``desc``, if ``autosum is None`` or ``param`` is not a class attribute, or it will be a summary of the class attribute's docstring. Notes ----- This does not have the autosummary functionality to display a method's signature, and hence is not used to format methods. It may be complicated to incorporate autosummary's signature mangling, as it relies on Sphinx's plugin mechanism. """ param = param.strip() # XXX: If changing the following, please check the rendering when param # ends with '_', e.g. 'word_' # See https://github.com/numpy/numpydoc/pull/144 display_param = '**%s**' % param if not fake_autosummary: return display_param, desc param_obj = getattr(self._obj, param, None) if not (callable(param_obj) or isinstance(param_obj, property) or inspect.isgetsetdescriptor(param_obj)): param_obj = None obj_doc = pydoc.getdoc(param_obj) if not (param_obj and obj_doc): return display_param, desc prefix = getattr(self, '_name', '') if prefix: autosum_prefix = '~%s.' % prefix link_prefix = '%s.' % prefix else: autosum_prefix = '' link_prefix = '' # Referenced object has a docstring display_param = ':obj:`%s <%s%s>`' % (param, link_prefix, param) if obj_doc: # Overwrite desc. Take summary logic of autosummary desc = re.split('\n\s*\n', obj_doc.strip(), 1)[0] # XXX: Should this have DOTALL? # It does not in autosummary m = re.search(r"^([A-Z].*?\.)(?:\s|$)", ' '.join(desc.split())) if m: desc = m.group(1).strip() else: desc = desc.partition('\n')[0] desc = desc.split('\n') return display_param, desc def _str_param_list(self, name, fake_autosummary=False): """Generate RST for a listing of parameters or similar Parameter names are displayed as bold text, and descriptions are in blockquotes. Descriptions may therefore contain block markup as well. Parameters ---------- name : str Section name (e.g. Parameters) fake_autosummary : bool When True, the parameter names may correspond to attributes of the object beign documented, usually ``property`` instances on a class. In this case, names will be linked to fuller descriptions. Returns ------- rst : list of str """ out = [] if self[name]: out += self._str_field_list(name) out += [''] for param, param_type, desc in self[name]: display_param, desc = self._process_param(param, desc, fake_autosummary) if param_type: out += self._str_indent(['%s : %s' % (display_param, param_type)]) else: out += self._str_indent([display_param]) if desc and self.use_blockquotes: out += [''] elif not desc: # empty definition desc = ['..'] out += self._str_indent(desc, 8) out += [''] return out @property def _obj(self): if hasattr(self, '_cls'): return self._cls elif hasattr(self, '_f'): return self._f return None def _str_member_list(self, name): """ Generate a member listing, autosummary:: table where possible, and a table where not. """ out = [] if self[name]: out += ['.. rubric:: %s' % name, ''] prefix = getattr(self, '_name', '') if prefix: prefix = '~%s.' % prefix autosum = [] others = [] for param, param_type, desc in self[name]: param = param.strip() # Check if the referenced member can have a docstring or not param_obj = getattr(self._obj, param, None) if not (callable(param_obj) or isinstance(param_obj, property) or inspect.isdatadescriptor(param_obj)): param_obj = None if param_obj and pydoc.getdoc(param_obj): # Referenced object has a docstring autosum += [" %s%s" % (prefix, param)] else: others.append((param, param_type, desc)) if autosum: out += ['.. autosummary::'] if self.class_members_toctree: out += [' :toctree:'] out += [''] + autosum if others: maxlen_0 = max(3, max([len(x[0]) + 4 for x in others])) hdr = sixu("=") * maxlen_0 + sixu(" ") + sixu("=") * 10 fmt = sixu('%%%ds %%s ') % (maxlen_0,) out += ['', '', hdr] for param, param_type, desc in others: desc = sixu(" ").join(x.strip() for x in desc).strip() if param_type: desc = "(%s) %s" % (param_type, desc) out += [fmt % ("**" + param.strip() + "**", desc)] out += [hdr] out += [''] return out def _str_section(self, name): out = [] if self[name]: out += self._str_header(name) content = textwrap.dedent("\n".join(self[name])).split("\n") out += content out += [''] return out def _str_see_also(self, func_role): out = [] if self['See Also']: see_also = super(SphinxDocString, self)._str_see_also(func_role) out = ['.. seealso::', ''] out += self._str_indent(see_also[2:]) return out def _str_warnings(self): out = [] if self['Warnings']: out = ['.. warning::', ''] out += self._str_indent(self['Warnings']) out += [''] return out def _str_index(self): idx = self['index'] out = [] if len(idx) == 0: return out out += ['.. index:: %s' % idx.get('default', '')] for section, references in idx.items(): if section == 'default': continue elif section == 'refguide': out += [' single: %s' % (', '.join(references))] else: out += [' %s: %s' % (section, ','.join(references))] out += [''] return out def _str_references(self): out = [] if self['References']: out += self._str_header('References') if isinstance(self['References'], str): self['References'] = [self['References']] out.extend(self['References']) out += [''] # Latex collects all references to a separate bibliography, # so we need to insert links to it if sphinx.__version__ >= "0.6": out += ['.. only:: latex', ''] else: out += ['.. latexonly::', ''] items = [] for line in self['References']: m = re.match(r'.. \[([a-z0-9._-]+)\]', line, re.I) if m: items.append(m.group(1)) out += [' ' + ", ".join(["[%s]_" % item for item in items]), ''] return out def _str_examples(self): examples_str = "\n".join(self['Examples']) if (self.use_plots and re.search(IMPORT_MATPLOTLIB_RE, examples_str) and 'plot::' not in examples_str): out = [] out += self._str_header('Examples') out += ['.. plot::', ''] out += self._str_indent(self['Examples']) out += [''] return out else: return self._str_section('Examples') def __str__(self, indent=0, func_role="obj"): ns = { 'signature': self._str_signature(), 'index': self._str_index(), 'summary': self._str_summary(), 'extended_summary': self._str_extended_summary(), 'parameters': self._str_param_list('Parameters'), 'returns': self._str_returns('Returns'), 'yields': self._str_returns('Yields'), 'other_parameters': self._str_param_list('Other Parameters'), 'raises': self._str_param_list('Raises'), 'warns': self._str_param_list('Warns'), 'warnings': self._str_warnings(), 'see_also': self._str_see_also(func_role), 'notes': self._str_section('Notes'), 'references': self._str_references(), 'examples': self._str_examples(), 'attributes': self._str_param_list('Attributes', fake_autosummary=True), 'methods': self._str_member_list('Methods'), } ns = dict((k, '\n'.join(v)) for k, v in ns.items()) rendered = self.template.render(**ns) return '\n'.join(self._str_indent(rendered.split('\n'), indent)) class SphinxFunctionDoc(SphinxDocString, FunctionDoc): def __init__(self, obj, doc=None, config={}): self.load_config(config) FunctionDoc.__init__(self, obj, doc=doc, config=config) class SphinxClassDoc(SphinxDocString, ClassDoc): def __init__(self, obj, doc=None, func_doc=None, config={}): self.load_config(config) ClassDoc.__init__(self, obj, doc=doc, func_doc=None, config=config) class SphinxObjDoc(SphinxDocString): def __init__(self, obj, doc=None, config={}): self._f = obj self.load_config(config) SphinxDocString.__init__(self, doc, config=config) def get_doc_object(obj, what=None, doc=None, config={}, builder=None): if what is None: if inspect.isclass(obj): what = 'class' elif inspect.ismodule(obj): what = 'module' elif isinstance(obj, collections.Callable): what = 'function' else: what = 'object' template_dirs = [os.path.join(os.path.dirname(__file__), 'templates')] if builder is not None: template_loader = BuiltinTemplateLoader() template_loader.init(builder, dirs=template_dirs) else: template_loader = FileSystemLoader(template_dirs) template_env = SandboxedEnvironment(loader=template_loader) config['template'] = template_env.get_template('numpydoc_docstring.rst') if what == 'class': return SphinxClassDoc(obj, func_doc=SphinxFunctionDoc, doc=doc, config=config) elif what in ('function', 'method'): return SphinxFunctionDoc(obj, doc=doc, config=config) else: if doc is None: doc = pydoc.getdoc(obj) return SphinxObjDoc(obj, doc, config=config) regions-0.4/astropy_helpers/astropy_helpers/extern/numpydoc/numpydoc.py0000644000076600000240000002620313467311012027106 0ustar deilstaff00000000000000""" ======== numpydoc ======== Sphinx extension that handles docstrings in the Numpy standard format. [1] It will: - Convert Parameters etc. sections to field lists. - Convert See Also section to a See also entry. - Renumber references. - Extract the signature from the docstring, if it can't be determined otherwise. .. [1] https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt """ from __future__ import division, absolute_import, print_function import sys import re import pydoc import inspect import collections import hashlib from docutils.nodes import citation, Text import sphinx from sphinx.addnodes import pending_xref, desc_content if sphinx.__version__ < '1.0.1': raise RuntimeError("Sphinx 1.0.1 or newer is required") from .docscrape_sphinx import get_doc_object, SphinxDocString from . import __version__ if sys.version_info[0] >= 3: sixu = lambda s: s else: sixu = lambda s: unicode(s, 'unicode_escape') HASH_LEN = 12 def rename_references(app, what, name, obj, options, lines): # decorate reference numbers so that there are no duplicates # these are later undecorated in the doctree, in relabel_references references = set() for line in lines: line = line.strip() m = re.match(sixu('^.. \\[(%s)\\]') % app.config.numpydoc_citation_re, line, re.I) if m: references.add(m.group(1)) if references: # we use a hash to mangle the reference name to avoid invalid names sha = hashlib.sha256() sha.update(name.encode('utf8')) prefix = 'R' + sha.hexdigest()[:HASH_LEN] for r in references: new_r = prefix + '-' + r for i, line in enumerate(lines): lines[i] = lines[i].replace(sixu('[%s]_') % r, sixu('[%s]_') % new_r) lines[i] = lines[i].replace(sixu('.. [%s]') % r, sixu('.. [%s]') % new_r) def _ascend(node, cls): while node and not isinstance(node, cls): node = node.parent return node def relabel_references(app, doc): # Change 'hash-ref' to 'ref' in label text for citation_node in doc.traverse(citation): if _ascend(citation_node, desc_content) is None: # no desc node in ancestry -> not in a docstring # XXX: should we also somehow check it's in a References section? continue label_node = citation_node[0] prefix, _, new_label = label_node[0].astext().partition('-') assert len(prefix) == HASH_LEN + 1 new_text = Text(new_label) label_node.replace(label_node[0], new_text) for id in citation_node['backrefs']: ref = doc.ids[id] ref_text = ref[0] # Sphinx has created pending_xref nodes with [reftext] text. def matching_pending_xref(node): return (isinstance(node, pending_xref) and node[0].astext() == '[%s]' % ref_text) for xref_node in ref.parent.traverse(matching_pending_xref): xref_node.replace(xref_node[0], Text('[%s]' % new_text)) ref.replace(ref_text, new_text.copy()) DEDUPLICATION_TAG = ' !! processed by numpydoc !!' def mangle_docstrings(app, what, name, obj, options, lines): if DEDUPLICATION_TAG in lines: return cfg = {'use_plots': app.config.numpydoc_use_plots, 'use_blockquotes': app.config.numpydoc_use_blockquotes, 'show_class_members': app.config.numpydoc_show_class_members, 'show_inherited_class_members': app.config.numpydoc_show_inherited_class_members, 'class_members_toctree': app.config.numpydoc_class_members_toctree} u_NL = sixu('\n') if what == 'module': # Strip top title pattern = '^\\s*[#*=]{4,}\\n[a-z0-9 -]+\\n[#*=]{4,}\\s*' title_re = re.compile(sixu(pattern), re.I | re.S) lines[:] = title_re.sub(sixu(''), u_NL.join(lines)).split(u_NL) else: doc = get_doc_object(obj, what, u_NL.join(lines), config=cfg, builder=app.builder) if sys.version_info[0] >= 3: doc = str(doc) else: doc = unicode(doc) lines[:] = doc.split(u_NL) if (app.config.numpydoc_edit_link and hasattr(obj, '__name__') and obj.__name__): if hasattr(obj, '__module__'): v = dict(full_name=sixu("%s.%s") % (obj.__module__, obj.__name__)) else: v = dict(full_name=obj.__name__) lines += [sixu(''), sixu('.. htmlonly::'), sixu('')] lines += [sixu(' %s') % x for x in (app.config.numpydoc_edit_link % v).split("\n")] # call function to replace reference numbers so that there are no # duplicates rename_references(app, what, name, obj, options, lines) lines += ['..', DEDUPLICATION_TAG] def mangle_signature(app, what, name, obj, options, sig, retann): # Do not try to inspect classes that don't define `__init__` if (inspect.isclass(obj) and (not hasattr(obj, '__init__') or 'initializes x; see ' in pydoc.getdoc(obj.__init__))): return '', '' if not (isinstance(obj, collections.Callable) or hasattr(obj, '__argspec_is_invalid_')): return if not hasattr(obj, '__doc__'): return doc = SphinxDocString(pydoc.getdoc(obj)) sig = doc['Signature'] or getattr(obj, '__text_signature__', None) if sig: sig = re.sub(sixu("^[^(]*"), sixu(""), sig) return sig, sixu('') def setup(app, get_doc_object_=get_doc_object): if not hasattr(app, 'add_config_value'): return # probably called by nose, better bail out global get_doc_object get_doc_object = get_doc_object_ app.connect('autodoc-process-docstring', mangle_docstrings) app.connect('autodoc-process-signature', mangle_signature) app.connect('doctree-read', relabel_references) app.add_config_value('numpydoc_edit_link', None, False) app.add_config_value('numpydoc_use_plots', None, False) app.add_config_value('numpydoc_use_blockquotes', None, False) app.add_config_value('numpydoc_show_class_members', True, True) app.add_config_value('numpydoc_show_inherited_class_members', True, True) app.add_config_value('numpydoc_class_members_toctree', True, True) app.add_config_value('numpydoc_citation_re', '[a-z0-9_.-]+', True) # Extra mangling domains app.add_domain(NumpyPythonDomain) app.add_domain(NumpyCDomain) app.setup_extension('sphinx.ext.autosummary') metadata = {'version': __version__, 'parallel_read_safe': True} return metadata # ------------------------------------------------------------------------------ # Docstring-mangling domains # ------------------------------------------------------------------------------ from docutils.statemachine import ViewList from sphinx.domains.c import CDomain from sphinx.domains.python import PythonDomain class ManglingDomainBase(object): directive_mangling_map = {} def __init__(self, *a, **kw): super(ManglingDomainBase, self).__init__(*a, **kw) self.wrap_mangling_directives() def wrap_mangling_directives(self): for name, objtype in list(self.directive_mangling_map.items()): self.directives[name] = wrap_mangling_directive( self.directives[name], objtype) class NumpyPythonDomain(ManglingDomainBase, PythonDomain): name = 'np' directive_mangling_map = { 'function': 'function', 'class': 'class', 'exception': 'class', 'method': 'function', 'classmethod': 'function', 'staticmethod': 'function', 'attribute': 'attribute', } indices = [] class NumpyCDomain(ManglingDomainBase, CDomain): name = 'np-c' directive_mangling_map = { 'function': 'function', 'member': 'attribute', 'macro': 'function', 'type': 'class', 'var': 'object', } def match_items(lines, content_old): """Create items for mangled lines. This function tries to match the lines in ``lines`` with the items (source file references and line numbers) in ``content_old``. The ``mangle_docstrings`` function changes the actual docstrings, but doesn't keep track of where each line came from. The manging does many operations on the original lines, which are hard to track afterwards. Many of the line changes come from deleting or inserting blank lines. This function tries to match lines by ignoring blank lines. All other changes (such as inserting figures or changes in the references) are completely ignored, so the generated line numbers will be off if ``mangle_docstrings`` does anything non-trivial. This is a best-effort function and the real fix would be to make ``mangle_docstrings`` actually keep track of the ``items`` together with the ``lines``. Examples -------- >>> lines = ['', 'A', '', 'B', ' ', '', 'C', 'D'] >>> lines_old = ['a', '', '', 'b', '', 'c'] >>> items_old = [('file1.py', 0), ('file1.py', 1), ('file1.py', 2), ... ('file2.py', 0), ('file2.py', 1), ('file2.py', 2)] >>> content_old = ViewList(lines_old, items=items_old) >>> match_items(lines, content_old) # doctest: +NORMALIZE_WHITESPACE [('file1.py', 0), ('file1.py', 0), ('file2.py', 0), ('file2.py', 0), ('file2.py', 2), ('file2.py', 2), ('file2.py', 2), ('file2.py', 2)] >>> # first 2 ``lines`` are matched to 'a', second 2 to 'b', rest to 'c' >>> # actual content is completely ignored. Notes ----- The algorithm tries to match any line in ``lines`` with one in ``lines_old``. It skips over all empty lines in ``lines_old`` and assigns this line number to all lines in ``lines``, unless a non-empty line is found in ``lines`` in which case it goes to the next line in ``lines_old``. """ items_new = [] lines_old = content_old.data items_old = content_old.items j = 0 for i, line in enumerate(lines): # go to next non-empty line in old: # line.strip() checks whether the string is all whitespace while j < len(lines_old) - 1 and not lines_old[j].strip(): j += 1 items_new.append(items_old[j]) if line.strip() and j < len(lines_old) - 1: j += 1 assert(len(items_new) == len(lines)) return items_new def wrap_mangling_directive(base_directive, objtype): class directive(base_directive): def run(self): env = self.state.document.settings.env name = None if self.arguments: m = re.match(r'^(.*\s+)?(.*?)(\(.*)?', self.arguments[0]) name = m.group(2).strip() if not name: name = self.arguments[0] lines = list(self.content) mangle_docstrings(env.app, objtype, name, None, None, lines) if self.content: items = match_items(lines, self.content) self.content = ViewList(lines, items=items, parent=self.content.parent) return base_directive.run(self) return directive regions-0.4/astropy_helpers/astropy_helpers/extern/numpydoc/templates/0000755000076600000240000000000013501657425026703 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/extern/numpydoc/templates/numpydoc_docstring.rst0000644000076600000240000000032613336766207033355 0ustar deilstaff00000000000000{{index}} {{summary}} {{extended_summary}} {{parameters}} {{returns}} {{yields}} {{other_parameters}} {{raises}} {{warns}} {{warnings}} {{see_also}} {{notes}} {{references}} {{examples}} {{attributes}} {{methods}} regions-0.4/astropy_helpers/astropy_helpers/extern/setup_package.py0000644000076600000240000000027513336766207026245 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst def get_package_data(): return {'astropy_helpers.extern': ['automodapi/templates/*/*.rst', 'numpydoc/templates/*.rst']} regions-0.4/astropy_helpers/astropy_helpers/git_helpers.py0000644000076600000240000001450113336766207024427 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ Utilities for retrieving revision information from a project's git repository. """ # Do not remove the following comment; it is used by # astropy_helpers.version_helpers to determine the beginning of the code in # this module # BEGIN import locale import os import subprocess import warnings def _decode_stdio(stream): try: stdio_encoding = locale.getdefaultlocale()[1] or 'utf-8' except ValueError: stdio_encoding = 'utf-8' try: text = stream.decode(stdio_encoding) except UnicodeDecodeError: # Final fallback text = stream.decode('latin1') return text def update_git_devstr(version, path=None): """ Updates the git revision string if and only if the path is being imported directly from a git working copy. This ensures that the revision number in the version string is accurate. """ try: # Quick way to determine if we're in git or not - returns '' if not devstr = get_git_devstr(sha=True, show_warning=False, path=path) except OSError: return version if not devstr: # Probably not in git so just pass silently return version if 'dev' in version: # update to the current git revision version_base = version.split('.dev', 1)[0] devstr = get_git_devstr(sha=False, show_warning=False, path=path) return version_base + '.dev' + devstr else: # otherwise it's already the true/release version return version def get_git_devstr(sha=False, show_warning=True, path=None): """ Determines the number of revisions in this repository. Parameters ---------- sha : bool If True, the full SHA1 hash will be returned. Otherwise, the total count of commits in the repository will be used as a "revision number". show_warning : bool If True, issue a warning if git returns an error code, otherwise errors pass silently. path : str or None If a string, specifies the directory to look in to find the git repository. If `None`, the current working directory is used, and must be the root of the git repository. If given a filename it uses the directory containing that file. Returns ------- devversion : str Either a string with the revision number (if `sha` is False), the SHA1 hash of the current commit (if `sha` is True), or an empty string if git version info could not be identified. """ if path is None: path = os.getcwd() if not os.path.isdir(path): path = os.path.abspath(os.path.dirname(path)) if sha: # Faster for getting just the hash of HEAD cmd = ['rev-parse', 'HEAD'] else: cmd = ['rev-list', '--count', 'HEAD'] def run_git(cmd): try: p = subprocess.Popen(['git'] + cmd, cwd=path, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) stdout, stderr = p.communicate() except OSError as e: if show_warning: warnings.warn('Error running git: ' + str(e)) return (None, b'', b'') if p.returncode == 128: if show_warning: warnings.warn('No git repository present at {0!r}! Using ' 'default dev version.'.format(path)) return (p.returncode, b'', b'') if p.returncode == 129: if show_warning: warnings.warn('Your git looks old (does it support {0}?); ' 'consider upgrading to v1.7.2 or ' 'later.'.format(cmd[0])) return (p.returncode, stdout, stderr) elif p.returncode != 0: if show_warning: warnings.warn('Git failed while determining revision ' 'count: {0}'.format(_decode_stdio(stderr))) return (p.returncode, stdout, stderr) return p.returncode, stdout, stderr returncode, stdout, stderr = run_git(cmd) if not sha and returncode == 128: # git returns 128 if the command is not run from within a git # repository tree. In this case, a warning is produced above but we # return the default dev version of '0'. return '0' elif not sha and returncode == 129: # git returns 129 if a command option failed to parse; in # particular this could happen in git versions older than 1.7.2 # where the --count option is not supported # Also use --abbrev-commit and --abbrev=0 to display the minimum # number of characters needed per-commit (rather than the full hash) cmd = ['rev-list', '--abbrev-commit', '--abbrev=0', 'HEAD'] returncode, stdout, stderr = run_git(cmd) # Fall back on the old method of getting all revisions and counting # the lines if returncode == 0: return str(stdout.count(b'\n')) else: return '' elif sha: return _decode_stdio(stdout)[:40] else: return _decode_stdio(stdout).strip() # This function is tested but it is only ever executed within a subprocess when # creating a fake package, so it doesn't get picked up by coverage metrics. def _get_repo_path(pathname, levels=None): # pragma: no cover """ Given a file or directory name, determine the root of the git repository this path is under. If given, this won't look any higher than ``levels`` (that is, if ``levels=0`` then the given path must be the root of the git repository and is returned if so. Returns `None` if the given path could not be determined to belong to a git repo. """ if os.path.isfile(pathname): current_dir = os.path.abspath(os.path.dirname(pathname)) elif os.path.isdir(pathname): current_dir = os.path.abspath(pathname) else: return None current_level = 0 while levels is None or current_level <= levels: if os.path.exists(os.path.join(current_dir, '.git')): return current_dir current_level += 1 if current_dir == os.path.dirname(current_dir): break current_dir = os.path.dirname(current_dir) return None regions-0.4/astropy_helpers/astropy_helpers/openmp_helpers.py0000644000076600000240000000611113467311012025121 0ustar deilstaff00000000000000# This module defines functions that can be used to check whether OpenMP is # available and if so what flags to use. To use this, import the # add_openmp_flags_if_available function in a setup_package.py file where you # are defining your extensions: # # from astropy_helpers.openmp_helpers import add_openmp_flags_if_available # # then call it with a single extension as the only argument: # # add_openmp_flags_if_available(extension) # # this will add the OpenMP flags if available. from __future__ import absolute_import, print_function import os import sys import glob import tempfile import subprocess from distutils import log from distutils.ccompiler import new_compiler from distutils.sysconfig import customize_compiler from distutils.errors import CompileError, LinkError from .distutils_helpers import get_compiler_option __all__ = ['add_openmp_flags_if_available'] CCODE = """ #include #include int main(void) { #pragma omp parallel printf("nthreads=%d\\n", omp_get_num_threads()); return 0; } """ def add_openmp_flags_if_available(extension): """ Add OpenMP compilation flags, if available (if not a warning will be printed to the console and no flags will be added) Returns `True` if the flags were added, `False` otherwise. """ ccompiler = new_compiler() customize_compiler(ccompiler) tmp_dir = tempfile.mkdtemp() start_dir = os.path.abspath('.') if get_compiler_option() == 'msvc': compile_flag = '-openmp' link_flag = '' else: compile_flag = '-fopenmp' link_flag = '-fopenmp' try: os.chdir(tmp_dir) with open('test_openmp.c', 'w') as f: f.write(CCODE) os.mkdir('objects') # Compile, link, and run test program ccompiler.compile(['test_openmp.c'], output_dir='objects', extra_postargs=[compile_flag]) ccompiler.link_executable(glob.glob(os.path.join('objects', '*' + ccompiler.obj_extension)), 'test_openmp', extra_postargs=[link_flag]) output = subprocess.check_output('./test_openmp').decode(sys.stdout.encoding or 'utf-8').splitlines() if 'nthreads=' in output[0]: nthreads = int(output[0].strip().split('=')[1]) if len(output) == nthreads: using_openmp = True else: log.warn("Unexpected number of lines from output of test OpenMP " "program (output was {0})".format(output)) using_openmp = False else: log.warn("Unexpected output from test OpenMP " "program (output was {0})".format(output)) using_openmp = False except (CompileError, LinkError): using_openmp = False finally: os.chdir(start_dir) if using_openmp: log.info("Compiling Cython extension with OpenMP support") extension.extra_compile_args.append(compile_flag) extension.extra_link_args.append(link_flag) else: log.warn("Cannot compile Cython extension with OpenMP, reverting to non-parallel code") return using_openmp regions-0.4/astropy_helpers/astropy_helpers/setup_helpers.py0000644000076600000240000006636013336766207025016 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ This module contains a number of utilities for use during setup/build/packaging that are useful to astropy as a whole. """ from __future__ import absolute_import, print_function import collections import os import re import subprocess import sys import traceback import warnings from distutils import log from distutils.dist import Distribution from distutils.errors import DistutilsOptionError, DistutilsModuleError from distutils.core import Extension from distutils.core import Command from distutils.command.sdist import sdist as DistutilsSdist from setuptools import find_packages as _find_packages from .distutils_helpers import (add_command_option, get_compiler_option, get_dummy_distribution, get_distutils_build_option, get_distutils_build_or_install_option) from .version_helpers import get_pkg_version_module from .utils import (walk_skip_hidden, import_file, extends_doc, resolve_name, AstropyDeprecationWarning) from .commands.build_ext import generate_build_ext_command from .commands.build_py import AstropyBuildPy from .commands.install import AstropyInstall from .commands.install_lib import AstropyInstallLib from .commands.register import AstropyRegister from .commands.test import AstropyTest # These imports are not used in this module, but are included for backwards # compat with older versions of this module from .utils import get_numpy_include_path, write_if_different # noqa from .commands.build_ext import should_build_with_cython, get_compiler_version # noqa _module_state = {'registered_commands': None, 'have_sphinx': False, 'package_cache': None, 'exclude_packages': set(), 'excludes_too_late': False} try: import sphinx # noqa _module_state['have_sphinx'] = True except ValueError as e: # This can occur deep in the bowels of Sphinx's imports by way of docutils # and an occurrence of this bug: http://bugs.python.org/issue18378 # In this case sphinx is effectively unusable if 'unknown locale' in e.args[0]: log.warn( "Possible misconfiguration of one of the environment variables " "LC_ALL, LC_CTYPES, LANG, or LANGUAGE. For an example of how to " "configure your system's language environment on OSX see " "http://blog.remibergsma.com/2012/07/10/" "setting-locales-correctly-on-mac-osx-terminal-application/") except ImportError: pass except SyntaxError: # occurs if markupsafe is recent version, which doesn't support Python 3.2 pass PY3 = sys.version_info[0] >= 3 # This adds a new keyword to the setup() function Distribution.skip_2to3 = [] def adjust_compiler(package): """ This function detects broken compilers and switches to another. If the environment variable CC is explicitly set, or a compiler is specified on the commandline, no override is performed -- the purpose here is to only override a default compiler. The specific compilers with problems are: * The default compiler in XCode-4.2, llvm-gcc-4.2, segfaults when compiling wcslib. The set of broken compilers can be updated by changing the compiler_mapping variable. It is a list of 2-tuples where the first in the pair is a regular expression matching the version of the broken compiler, and the second is the compiler to change to. """ warnings.warn( 'Direct use of the adjust_compiler function in setup.py is ' 'deprecated and can be removed from your setup.py. This ' 'functionality is now incorporated directly into the build_ext ' 'command.', AstropyDeprecationWarning) def get_debug_option(packagename): """ Determines if the build is in debug mode. Returns ------- debug : bool True if the current build was started with the debug option, False otherwise. """ try: current_debug = get_pkg_version_module(packagename, fromlist=['debug'])[0] except (ImportError, AttributeError): current_debug = None # Only modify the debug flag if one of the build commands was explicitly # run (i.e. not as a sub-command of something else) dist = get_dummy_distribution() if any(cmd in dist.commands for cmd in ['build', 'build_ext']): debug = bool(get_distutils_build_option('debug')) else: debug = bool(current_debug) if current_debug is not None and current_debug != debug: build_ext_cmd = dist.get_command_class('build_ext') build_ext_cmd.force_rebuild = True return debug def add_exclude_packages(excludes): if _module_state['excludes_too_late']: raise RuntimeError( "add_package_excludes must be called before all other setup helper " "functions in order to properly handle excluded packages") _module_state['exclude_packages'].update(set(excludes)) def register_commands(package, version, release, srcdir='.'): if _module_state['registered_commands'] is not None: return _module_state['registered_commands'] if _module_state['have_sphinx']: try: from .commands.build_sphinx import (AstropyBuildSphinx, AstropyBuildDocs) except ImportError: AstropyBuildSphinx = AstropyBuildDocs = FakeBuildSphinx else: AstropyBuildSphinx = AstropyBuildDocs = FakeBuildSphinx _module_state['registered_commands'] = registered_commands = { 'test': generate_test_command(package), # Use distutils' sdist because it respects package_data. # setuptools/distributes sdist requires duplication of information in # MANIFEST.in 'sdist': DistutilsSdist, # The exact form of the build_ext command depends on whether or not # we're building a release version 'build_ext': generate_build_ext_command(package, release), # We have a custom build_py to generate the default configuration file 'build_py': AstropyBuildPy, # Since install can (in some circumstances) be run without # first building, we also need to override install and # install_lib. See #2223 'install': AstropyInstall, 'install_lib': AstropyInstallLib, 'register': AstropyRegister, 'build_sphinx': AstropyBuildSphinx, 'build_docs': AstropyBuildDocs } # Need to override the __name__ here so that the commandline options are # presented as being related to the "build" command, for example; normally # this wouldn't be necessary since commands also have a command_name # attribute, but there is a bug in distutils' help display code that it # uses __name__ instead of command_name. Yay distutils! for name, cls in registered_commands.items(): cls.__name__ = name # Add a few custom options; more of these can be added by specific packages # later for option in [ ('use-system-libraries', "Use system libraries whenever possible", True)]: add_command_option('build', *option) add_command_option('install', *option) add_command_hooks(registered_commands, srcdir=srcdir) return registered_commands def add_command_hooks(commands, srcdir='.'): """ Look through setup_package.py modules for functions with names like ``pre__hook`` and ``post__hook`` where ```` is the name of a ``setup.py`` command (e.g. build_ext). If either hook is present this adds a wrapped version of that command to the passed in ``commands`` `dict`. ``commands`` may be pre-populated with other custom distutils command classes that should be wrapped if there are hooks for them (e.g. `AstropyBuildPy`). """ hook_re = re.compile(r'^(pre|post)_(.+)_hook$') # Distutils commands have a method of the same name, but it is not a # *classmethod* (which probably didn't exist when distutils was first # written) def get_command_name(cmdcls): if hasattr(cmdcls, 'command_name'): return cmdcls.command_name else: return cmdcls.__name__ packages = filter_packages(find_packages(srcdir)) dist = get_dummy_distribution() hooks = collections.defaultdict(dict) for setuppkg in iter_setup_packages(srcdir, packages): for name, obj in vars(setuppkg).items(): match = hook_re.match(name) if not match: continue hook_type = match.group(1) cmd_name = match.group(2) if hook_type not in hooks[cmd_name]: hooks[cmd_name][hook_type] = [] hooks[cmd_name][hook_type].append((setuppkg.__name__, obj)) for cmd_name, cmd_hooks in hooks.items(): commands[cmd_name] = generate_hooked_command( cmd_name, dist.get_command_class(cmd_name), cmd_hooks) def generate_hooked_command(cmd_name, cmd_cls, hooks): """ Returns a generated subclass of ``cmd_cls`` that runs the pre- and post-command hooks for that command before and after the ``cmd_cls.run`` method. """ def run(self, orig_run=cmd_cls.run): self.run_command_hooks('pre_hooks') orig_run(self) self.run_command_hooks('post_hooks') return type(cmd_name, (cmd_cls, object), {'run': run, 'run_command_hooks': run_command_hooks, 'pre_hooks': hooks.get('pre', []), 'post_hooks': hooks.get('post', [])}) def run_command_hooks(cmd_obj, hook_kind): """Run hooks registered for that command and phase. *cmd_obj* is a finalized command object; *hook_kind* is either 'pre_hook' or 'post_hook'. """ hooks = getattr(cmd_obj, hook_kind, None) if not hooks: return for modname, hook in hooks: if isinstance(hook, str): try: hook_obj = resolve_name(hook) except ImportError as exc: raise DistutilsModuleError( 'cannot find hook {0}: {1}'.format(hook, exc)) else: hook_obj = hook if not callable(hook_obj): raise DistutilsOptionError('hook {0!r} is not callable' % hook) log.info('running {0} from {1} for {2} command'.format( hook_kind.rstrip('s'), modname, cmd_obj.get_command_name())) try: hook_obj(cmd_obj) except Exception: log.error('{0} command hook {1} raised an exception: %s\n'.format( hook_obj.__name__, cmd_obj.get_command_name())) log.error(traceback.format_exc()) sys.exit(1) def generate_test_command(package_name): """ Creates a custom 'test' command for the given package which sets the command's ``package_name`` class attribute to the name of the package being tested. """ return type(package_name.title() + 'Test', (AstropyTest,), {'package_name': package_name}) def update_package_files(srcdir, extensions, package_data, packagenames, package_dirs): """ This function is deprecated and maintained for backward compatibility with affiliated packages. Affiliated packages should update their setup.py to use `get_package_info` instead. """ info = get_package_info(srcdir) extensions.extend(info['ext_modules']) package_data.update(info['package_data']) packagenames = list(set(packagenames + info['packages'])) package_dirs.update(info['package_dir']) def get_package_info(srcdir='.', exclude=()): """ Collates all of the information for building all subpackages and returns a dictionary of keyword arguments that can be passed directly to `distutils.setup`. The purpose of this function is to allow subpackages to update the arguments to the package's ``setup()`` function in its setup.py script, rather than having to specify all extensions/package data directly in the ``setup.py``. See Astropy's own ``setup.py`` for example usage and the Astropy development docs for more details. This function obtains that information by iterating through all packages in ``srcdir`` and locating a ``setup_package.py`` module. This module can contain the following functions: ``get_extensions()``, ``get_package_data()``, ``get_build_options()``, ``get_external_libraries()``, and ``requires_2to3()``. Each of those functions take no arguments. - ``get_extensions`` returns a list of `distutils.extension.Extension` objects. - ``get_package_data()`` returns a dict formatted as required by the ``package_data`` argument to ``setup()``. - ``get_build_options()`` returns a list of tuples describing the extra build options to add. - ``get_external_libraries()`` returns a list of libraries that can optionally be built using external dependencies. - ``get_entry_points()`` returns a dict formatted as required by the ``entry_points`` argument to ``setup()``. - ``requires_2to3()`` should return `True` when the source code requires `2to3` processing to run on Python 3.x. If ``requires_2to3()`` is missing, it is assumed to return `True`. """ ext_modules = [] packages = [] package_data = {} package_dir = {} skip_2to3 = [] if exclude: warnings.warn( "Use of the exclude parameter is no longer supported since it does " "not work as expected. Use add_exclude_packages instead. Note that " "it must be called prior to any other calls from setup helpers.", AstropyDeprecationWarning) # Use the find_packages tool to locate all packages and modules packages = filter_packages(find_packages(srcdir, exclude=exclude)) # Update package_dir if the package lies in a subdirectory if srcdir != '.': package_dir[''] = srcdir # For each of the setup_package.py modules, extract any # information that is needed to install them. The build options # are extracted first, so that their values will be available in # subsequent calls to `get_extensions`, etc. for setuppkg in iter_setup_packages(srcdir, packages): if hasattr(setuppkg, 'get_build_options'): options = setuppkg.get_build_options() for option in options: add_command_option('build', *option) if hasattr(setuppkg, 'get_external_libraries'): libraries = setuppkg.get_external_libraries() for library in libraries: add_external_library(library) if hasattr(setuppkg, 'requires_2to3'): requires_2to3 = setuppkg.requires_2to3() else: requires_2to3 = True if not requires_2to3: skip_2to3.append( os.path.dirname(setuppkg.__file__)) for setuppkg in iter_setup_packages(srcdir, packages): # get_extensions must include any Cython extensions by their .pyx # filename. if hasattr(setuppkg, 'get_extensions'): ext_modules.extend(setuppkg.get_extensions()) if hasattr(setuppkg, 'get_package_data'): package_data.update(setuppkg.get_package_data()) # Locate any .pyx files not already specified, and add their extensions in. # The default include dirs include numpy to facilitate numerical work. ext_modules.extend(get_cython_extensions(srcdir, packages, ext_modules, ['numpy'])) # Now remove extensions that have the special name 'skip_cython', as they # exist Only to indicate that the cython extensions shouldn't be built for i, ext in reversed(list(enumerate(ext_modules))): if ext.name == 'skip_cython': del ext_modules[i] # On Microsoft compilers, we need to pass the '/MANIFEST' # commandline argument. This was the default on MSVC 9.0, but is # now required on MSVC 10.0, but it doesn't seem to hurt to add # it unconditionally. if get_compiler_option() == 'msvc': for ext in ext_modules: ext.extra_link_args.append('/MANIFEST') return { 'ext_modules': ext_modules, 'packages': packages, 'package_dir': package_dir, 'package_data': package_data, 'skip_2to3': skip_2to3 } def iter_setup_packages(srcdir, packages): """ A generator that finds and imports all of the ``setup_package.py`` modules in the source packages. Returns ------- modgen : generator A generator that yields (modname, mod), where `mod` is the module and `modname` is the module name for the ``setup_package.py`` modules. """ for packagename in packages: package_parts = packagename.split('.') package_path = os.path.join(srcdir, *package_parts) setup_package = os.path.relpath( os.path.join(package_path, 'setup_package.py')) if os.path.isfile(setup_package): module = import_file(setup_package, name=packagename + '.setup_package') yield module def iter_pyx_files(package_dir, package_name): """ A generator that yields Cython source files (ending in '.pyx') in the source packages. Returns ------- pyxgen : generator A generator that yields (extmod, fullfn) where `extmod` is the full name of the module that the .pyx file would live in based on the source directory structure, and `fullfn` is the path to the .pyx file. """ for dirpath, dirnames, filenames in walk_skip_hidden(package_dir): for fn in filenames: if fn.endswith('.pyx'): fullfn = os.path.relpath(os.path.join(dirpath, fn)) # Package must match file name extmod = '.'.join([package_name, fn[:-4]]) yield (extmod, fullfn) break # Don't recurse into subdirectories def get_cython_extensions(srcdir, packages, prevextensions=tuple(), extincludedirs=None): """ Looks for Cython files and generates Extensions if needed. Parameters ---------- srcdir : str Path to the root of the source directory to search. prevextensions : list of `~distutils.core.Extension` objects The extensions that are already defined. Any .pyx files already here will be ignored. extincludedirs : list of str or None Directories to include as the `include_dirs` argument to the generated `~distutils.core.Extension` objects. Returns ------- exts : list of `~distutils.core.Extension` objects The new extensions that are needed to compile all .pyx files (does not include any already in `prevextensions`). """ # Vanilla setuptools and old versions of distribute include Cython files # as .c files in the sources, not .pyx, so we cannot simply look for # existing .pyx sources in the previous sources, but we should also check # for .c files with the same remaining filename. So we look for .pyx and # .c files, and we strip the extension. prevsourcepaths = [] ext_modules = [] for ext in prevextensions: for s in ext.sources: if s.endswith(('.pyx', '.c', '.cpp')): sourcepath = os.path.realpath(os.path.splitext(s)[0]) prevsourcepaths.append(sourcepath) for package_name in packages: package_parts = package_name.split('.') package_path = os.path.join(srcdir, *package_parts) for extmod, pyxfn in iter_pyx_files(package_path, package_name): sourcepath = os.path.realpath(os.path.splitext(pyxfn)[0]) if sourcepath not in prevsourcepaths: ext_modules.append(Extension(extmod, [pyxfn], include_dirs=extincludedirs)) return ext_modules class DistutilsExtensionArgs(collections.defaultdict): """ A special dictionary whose default values are the empty list. This is useful for building up a set of arguments for `distutils.Extension` without worrying whether the entry is already present. """ def __init__(self, *args, **kwargs): def default_factory(): return [] super(DistutilsExtensionArgs, self).__init__( default_factory, *args, **kwargs) def update(self, other): for key, val in other.items(): self[key].extend(val) def pkg_config(packages, default_libraries, executable='pkg-config'): """ Uses pkg-config to update a set of distutils Extension arguments to include the flags necessary to link against the given packages. If the pkg-config lookup fails, default_libraries is applied to libraries. Parameters ---------- packages : list of str A list of pkg-config packages to look up. default_libraries : list of str A list of library names to use if the pkg-config lookup fails. Returns ------- config : dict A dictionary containing keyword arguments to `distutils.Extension`. These entries include: - ``include_dirs``: A list of include directories - ``library_dirs``: A list of library directories - ``libraries``: A list of libraries - ``define_macros``: A list of macro defines - ``undef_macros``: A list of macros to undefine - ``extra_compile_args``: A list of extra arguments to pass to the compiler """ flag_map = {'-I': 'include_dirs', '-L': 'library_dirs', '-l': 'libraries', '-D': 'define_macros', '-U': 'undef_macros'} command = "{0} --libs --cflags {1}".format(executable, ' '.join(packages)), result = DistutilsExtensionArgs() try: pipe = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE) output = pipe.communicate()[0].strip() except subprocess.CalledProcessError as e: lines = [ ("{0} failed. This may cause the build to fail below." .format(executable)), " command: {0}".format(e.cmd), " returncode: {0}".format(e.returncode), " output: {0}".format(e.output) ] log.warn('\n'.join(lines)) result['libraries'].extend(default_libraries) else: if pipe.returncode != 0: lines = [ "pkg-config could not lookup up package(s) {0}.".format( ", ".join(packages)), "This may cause the build to fail below." ] log.warn('\n'.join(lines)) result['libraries'].extend(default_libraries) else: for token in output.split(): # It's not clear what encoding the output of # pkg-config will come to us in. It will probably be # some combination of pure ASCII (for the compiler # flags) and the filesystem encoding (for any argument # that includes directories or filenames), but this is # just conjecture, as the pkg-config documentation # doesn't seem to address it. arg = token[:2].decode('ascii') value = token[2:].decode(sys.getfilesystemencoding()) if arg in flag_map: if arg == '-D': value = tuple(value.split('=', 1)) result[flag_map[arg]].append(value) else: result['extra_compile_args'].append(value) return result def add_external_library(library): """ Add a build option for selecting the internal or system copy of a library. Parameters ---------- library : str The name of the library. If the library is `foo`, the build option will be called `--use-system-foo`. """ for command in ['build', 'build_ext', 'install']: add_command_option(command, str('use-system-' + library), 'Use the system {0} library'.format(library), is_bool=True) def use_system_library(library): """ Returns `True` if the build configuration indicates that the given library should use the system copy of the library rather than the internal one. For the given library `foo`, this will be `True` if `--use-system-foo` or `--use-system-libraries` was provided at the commandline or in `setup.cfg`. Parameters ---------- library : str The name of the library Returns ------- use_system : bool `True` if the build should use the system copy of the library. """ return ( get_distutils_build_or_install_option('use_system_{0}'.format(library)) or get_distutils_build_or_install_option('use_system_libraries')) @extends_doc(_find_packages) def find_packages(where='.', exclude=(), invalidate_cache=False): """ This version of ``find_packages`` caches previous results to speed up subsequent calls. Use ``invalide_cache=True`` to ignore cached results from previous ``find_packages`` calls, and repeat the package search. """ if exclude: warnings.warn( "Use of the exclude parameter is no longer supported since it does " "not work as expected. Use add_exclude_packages instead. Note that " "it must be called prior to any other calls from setup helpers.", AstropyDeprecationWarning) # Calling add_exclude_packages after this point will have no effect _module_state['excludes_too_late'] = True if not invalidate_cache and _module_state['package_cache'] is not None: return _module_state['package_cache'] packages = _find_packages( where=where, exclude=list(_module_state['exclude_packages'])) _module_state['package_cache'] = packages return packages def filter_packages(packagenames): """ Removes some packages from the package list that shouldn't be installed on the current version of Python. """ if PY3: exclude = '_py2' else: exclude = '_py3' return [x for x in packagenames if not x.endswith(exclude)] class FakeBuildSphinx(Command): """ A dummy build_sphinx command that is called if Sphinx is not installed and displays a relevant error message """ # user options inherited from sphinx.setup_command.BuildDoc user_options = [ ('fresh-env', 'E', ''), ('all-files', 'a', ''), ('source-dir=', 's', ''), ('build-dir=', None, ''), ('config-dir=', 'c', ''), ('builder=', 'b', ''), ('project=', None, ''), ('version=', None, ''), ('release=', None, ''), ('today=', None, ''), ('link-index', 'i', '')] # user options appended in astropy.setup_helpers.AstropyBuildSphinx user_options.append(('warnings-returncode', 'w', '')) user_options.append(('clean-docs', 'l', '')) user_options.append(('no-intersphinx', 'n', '')) user_options.append(('open-docs-in-browser', 'o', '')) def initialize_options(self): try: raise RuntimeError("Sphinx and its dependencies must be installed " "for build_docs.") except: log.error('error: Sphinx and its dependencies must be installed ' 'for build_docs.') sys.exit(1) regions-0.4/astropy_helpers/astropy_helpers/sphinx/0000755000076600000240000000000013501657425023053 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/sphinx/__init__.py0000644000076600000240000000066513336766207025200 0ustar deilstaff00000000000000""" This package contains utilities and extensions for the Astropy sphinx documentation. In particular, the `astropy.sphinx.conf` should be imported by the sphinx ``conf.py`` file for affiliated packages that wish to make use of the Astropy documentation format. Note that some sphinx extensions which are bundled as-is (numpydoc and sphinx-automodapi) are included in astropy_helpers.extern rather than astropy_helpers.sphinx.ext. """ regions-0.4/astropy_helpers/astropy_helpers/sphinx/conf.py0000644000076600000240000002714113477530461024361 0ustar deilstaff00000000000000# -*- coding: utf-8 -*- # Licensed under a 3-clause BSD style license - see LICENSE.rst # # Astropy shared Sphinx settings. These settings are shared between # astropy itself and affiliated packages. # # Note that not all possible configuration values are present in this file. # # All configuration values have a default; values that are commented out # serve to show the default. import os import sys import warnings from os import path import sphinx from distutils.version import LooseVersion # -- General configuration ---------------------------------------------------- # The version check in Sphinx itself can only compare the major and # minor parts of the version number, not the micro. To do a more # specific version check, call check_sphinx_version("x.y.z.") from # your project's conf.py needs_sphinx = '1.3' on_rtd = os.environ.get('READTHEDOCS', None) == 'True' def check_sphinx_version(expected_version): sphinx_version = LooseVersion(sphinx.__version__) expected_version = LooseVersion(expected_version) if sphinx_version < expected_version: raise RuntimeError( "At least Sphinx version {0} is required to build this " "documentation. Found {1}.".format( expected_version, sphinx_version)) # Configuration for intersphinx: refer to the Python standard library. intersphinx_mapping = { 'python': ('https://docs.python.org/3/', (None, 'http://data.astropy.org/intersphinx/python3.inv')), 'pythonloc': ('http://docs.python.org/', path.abspath(path.join(path.dirname(__file__), 'local/python3_local_links.inv'))), 'numpy': ('https://docs.scipy.org/doc/numpy/', (None, 'http://data.astropy.org/intersphinx/numpy.inv')), 'scipy': ('https://docs.scipy.org/doc/scipy/reference/', (None, 'http://data.astropy.org/intersphinx/scipy.inv')), 'matplotlib': ('http://matplotlib.org/', (None, 'http://data.astropy.org/intersphinx/matplotlib.inv')), 'astropy': ('http://docs.astropy.org/en/stable/', None), 'h5py': ('http://docs.h5py.org/en/stable/', None)} if sys.version_info[0] == 2: intersphinx_mapping['python'] = ( 'https://docs.python.org/2/', (None, 'http://data.astropy.org/intersphinx/python2.inv')) intersphinx_mapping['pythonloc'] = ( 'http://docs.python.org/', path.abspath(path.join(path.dirname(__file__), 'local/python2_local_links.inv'))) # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_build'] # Add any paths that contain templates here, relative to this directory. # templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # The reST default role (used for this markup: `text`) to use for all # documents. Set to the "smart" one. default_role = 'obj' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # This is added to the end of RST files - a good place to put substitutions to # be used globally. rst_epilog = """ .. _Astropy: http://astropy.org """ # A list of warning types to suppress arbitrary warning messages. We mean to # override directives in astropy_helpers.sphinx.ext.autodoc_enhancements, # thus need to ignore those warning. This can be removed once the patch gets # released in upstream Sphinx (https://github.com/sphinx-doc/sphinx/pull/1843). # Suppress the warnings requires Sphinx v1.4.2 suppress_warnings = ['app.add_directive', ] # -- Project information ------------------------------------------------------ # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. #pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # -- Settings for extensions and extension options ---------------------------- # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx.ext.todo', 'sphinx.ext.coverage', 'sphinx.ext.inheritance_diagram', 'sphinx.ext.viewcode', 'astropy_helpers.extern.numpydoc', 'astropy_helpers.extern.automodapi.automodapi', 'astropy_helpers.extern.automodapi.smart_resolver', 'astropy_helpers.sphinx.ext.doctest', 'astropy_helpers.sphinx.ext.changelog_links'] if not on_rtd and LooseVersion(sphinx.__version__) < LooseVersion('1.4'): extensions.append('sphinx.ext.pngmath') else: extensions.append('sphinx.ext.mathjax') try: import matplotlib.sphinxext.plot_directive extensions += [matplotlib.sphinxext.plot_directive.__name__] # AttributeError is checked here in case matplotlib is installed but # Sphinx isn't. Note that this module is imported by the config file # generator, even if we're not building the docs. except (ImportError, AttributeError): warnings.warn( "matplotlib's plot_directive could not be imported. " + "Inline plots will not be included in the output") # Don't show summaries of the members in each class along with the # class' docstring numpydoc_show_class_members = False autosummary_generate = True automodapi_toctreedirnm = 'api' # Class documentation should contain *both* the class docstring and # the __init__ docstring autoclass_content = "both" # Render inheritance diagrams in SVG graphviz_output_format = "svg" graphviz_dot_args = [ '-Nfontsize=10', '-Nfontname=Helvetica Neue, Helvetica, Arial, sans-serif', '-Efontsize=10', '-Efontname=Helvetica Neue, Helvetica, Arial, sans-serif', '-Gfontsize=10', '-Gfontname=Helvetica Neue, Helvetica, Arial, sans-serif' ] # -- Options for HTML output ------------------------------------------------- # Add any paths that contain custom themes here, relative to this directory. html_theme_path = [path.abspath(path.join(path.dirname(__file__), 'themes'))] # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'bootstrap-astropy' # Custom sidebar templates, maps document names to template names. html_sidebars = { '**': ['localtoc.html'], 'search': [], 'genindex': [], 'py-modindex': [], } # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. # included in the bootstrap-astropy theme html_favicon = path.join(html_theme_path[0], html_theme, 'static', 'astropy_logo.ico') # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. html_last_updated_fmt = '%d %b %Y' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # -- Options for LaTeX output ------------------------------------------------ # The paper size ('letter' or 'a4'). #latex_paper_size = 'letter' # The font size ('10pt', '11pt' or '12pt'). #latex_font_size = '10pt' # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. latex_toplevel_sectioning = 'part' # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False latex_elements = {} # Additional stuff for the LaTeX preamble. latex_elements['preamble'] = r""" % Use a more modern-looking monospace font \usepackage{inconsolata} % The enumitem package provides unlimited nesting of lists and enums. % Sphinx may use this in the future, in which case this can be removed. % See https://bitbucket.org/birkenfeld/sphinx/issue/777/latex-output-too-deeply-nested \usepackage{enumitem} \setlistdepth{15} % In the parameters section, place a newline after the Parameters % header. (This is stolen directly from Numpy's conf.py, since it % affects Numpy-style docstrings). \usepackage{expdlist} \let\latexdescription=\description \def\description{\latexdescription{}{} \breaklabel} % Support the superscript Unicode numbers used by the "unicode" units % formatter \DeclareUnicodeCharacter{2070}{\ensuremath{^0}} \DeclareUnicodeCharacter{00B9}{\ensuremath{^1}} \DeclareUnicodeCharacter{00B2}{\ensuremath{^2}} \DeclareUnicodeCharacter{00B3}{\ensuremath{^3}} \DeclareUnicodeCharacter{2074}{\ensuremath{^4}} \DeclareUnicodeCharacter{2075}{\ensuremath{^5}} \DeclareUnicodeCharacter{2076}{\ensuremath{^6}} \DeclareUnicodeCharacter{2077}{\ensuremath{^7}} \DeclareUnicodeCharacter{2078}{\ensuremath{^8}} \DeclareUnicodeCharacter{2079}{\ensuremath{^9}} \DeclareUnicodeCharacter{207B}{\ensuremath{^-}} \DeclareUnicodeCharacter{00B0}{\ensuremath{^{\circ}}} \DeclareUnicodeCharacter{2032}{\ensuremath{^{\prime}}} \DeclareUnicodeCharacter{2033}{\ensuremath{^{\prime\prime}}} % Make the "warning" and "notes" sections use a sans-serif font to % make them stand out more. \renewenvironment{notice}[2]{ \def\py@noticetype{#1} \csname py@noticestart@#1\endcsname \textsf{\textbf{#2}} }{\csname py@noticeend@\py@noticetype\endcsname} """ # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # -- Options for the linkcheck builder ---------------------------------------- # A timeout value, in seconds, for the linkcheck builder linkcheck_timeout = 60 regions-0.4/astropy_helpers/astropy_helpers/sphinx/ext/0000755000076600000240000000000013501657425023653 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/sphinx/ext/__init__.py0000644000076600000240000000010213336766207025762 0ustar deilstaff00000000000000from __future__ import division, absolute_import, print_function regions-0.4/astropy_helpers/astropy_helpers/sphinx/ext/changelog_links.py0000644000076600000240000000617113467311012027347 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ This sphinx extension makes the issue numbers in the changelog into links to GitHub issues. """ from __future__ import print_function import re from distutils.version import LooseVersion from docutils.nodes import Text, reference from sphinx import __version__ SPHINX_LT_16 = LooseVersion(__version__) < LooseVersion('1.6') BLOCK_PATTERN = re.compile('\[#.+\]', flags=re.DOTALL) ISSUE_PATTERN = re.compile('#[0-9]+') def process_changelog_links(app, doctree, docname): for rex in app.changelog_links_rexes: if rex.match(docname): break else: # if the doc doesn't match any of the changelog regexes, don't process return if SPHINX_LT_16: info = app.info else: from sphinx.util import logging info = logging.getLogger(__name__).info info('[changelog_links] Adding changelog links to "{0}"'.format(docname)) for item in doctree.traverse(): if not isinstance(item, Text): continue # We build a new list of items to replace the current item. If # a link is found, we need to use a 'reference' item. children = [] # First cycle through blocks of issues (delimited by []) then # iterate inside each one to find the individual issues. prev_block_end = 0 for block in BLOCK_PATTERN.finditer(item): block_start, block_end = block.start(), block.end() children.append(Text(item[prev_block_end:block_start])) block = item[block_start:block_end] prev_end = 0 for m in ISSUE_PATTERN.finditer(block): start, end = m.start(), m.end() children.append(Text(block[prev_end:start])) issue_number = block[start:end] refuri = app.config.github_issues_url + issue_number[1:] children.append(reference(text=issue_number, name=issue_number, refuri=refuri)) prev_end = end prev_block_end = block_end # If no issues were found, this adds the whole item, # otherwise it adds the remaining text. children.append(Text(block[prev_end:block_end])) # If no blocks were found, this adds the whole item, otherwise # it adds the remaining text. children.append(Text(item[prev_block_end:])) # Replace item by the new list of items we have generated, # which may contain links. item.parent.replace(item, children) def setup_patterns_rexes(app): app.changelog_links_rexes = [re.compile(pat) for pat in app.config.changelog_links_docpattern] def setup(app): app.connect('doctree-resolved', process_changelog_links) app.connect('builder-inited', setup_patterns_rexes) app.add_config_value('github_issues_url', None, True) app.add_config_value('changelog_links_docpattern', ['.*changelog.*', 'whatsnew/.*'], True) return {'parallel_read_safe': True, 'parallel_write_safe': True} regions-0.4/astropy_helpers/astropy_helpers/sphinx/ext/doctest.py0000644000076600000240000000364113336766207025703 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ This is a set of three directives that allow us to insert metadata about doctests into the .rst files so the testing framework knows which tests to skip. This is quite different from the doctest extension in Sphinx itself, which actually does something. For astropy, all of the testing is centrally managed from py.test and Sphinx is not used for running tests. """ import re from docutils.nodes import literal_block from docutils.parsers.rst import Directive class DoctestSkipDirective(Directive): has_content = True def run(self): # Check if there is any valid argument, and skip it. Currently only # 'win32' is supported in astropy.tests.pytest_plugins. if re.match('win32', self.content[0]): self.content = self.content[2:] code = '\n'.join(self.content) return [literal_block(code, code)] class DoctestOmitDirective(Directive): has_content = True def run(self): # Simply do not add any content when this directive is encountered return [] class DoctestRequiresDirective(DoctestSkipDirective): # This is silly, but we really support an unbounded number of # optional arguments optional_arguments = 64 def setup(app): app.add_directive('doctest-requires', DoctestRequiresDirective) app.add_directive('doctest-skip', DoctestSkipDirective) app.add_directive('doctest-skip-all', DoctestSkipDirective) app.add_directive('doctest', DoctestSkipDirective) # Code blocks that use this directive will not appear in the generated # documentation. This is intended to hide boilerplate code that is only # useful for testing documentation using doctest, but does not actually # belong in the documentation itself. app.add_directive('testsetup', DoctestOmitDirective) return {'parallel_read_safe': True, 'parallel_write_safe': True} regions-0.4/astropy_helpers/astropy_helpers/sphinx/ext/edit_on_github.py0000644000076600000240000001346413336766207027225 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ This extension makes it easy to edit documentation on github. It adds links associated with each docstring that go to the corresponding view source page on Github. From there, the user can push the "Edit" button, edit the docstring, and submit a pull request. It has the following configuration options (to be set in the project's ``conf.py``): * ``edit_on_github_project`` The name of the github project, in the form "username/projectname". * ``edit_on_github_branch`` The name of the branch to edit. If this is a released version, this should be a git tag referring to that version. For a dev version, it often makes sense for it to be "master". It may also be a git hash. * ``edit_on_github_source_root`` The location within the source tree of the root of the Python package. Defaults to "lib". * ``edit_on_github_doc_root`` The location within the source tree of the root of the documentation source. Defaults to "doc", but it may make sense to set it to "doc/source" if the project uses a separate source directory. * ``edit_on_github_docstring_message`` The phrase displayed in the links to edit a docstring. Defaults to "[edit on github]". * ``edit_on_github_page_message`` The phrase displayed in the links to edit a RST page. Defaults to "[edit this page on github]". * ``edit_on_github_help_message`` The phrase displayed as a tooltip on the edit links. Defaults to "Push the Edit button on the next page" * ``edit_on_github_skip_regex`` When the path to the .rst file matches this regular expression, no "edit this page on github" link will be added. Defaults to ``"_.*"``. """ import inspect import os import re import sys from docutils import nodes from sphinx import addnodes def import_object(modname, name): """ Import the object given by *modname* and *name* and return it. If not found, or the import fails, returns None. """ try: __import__(modname) mod = sys.modules[modname] obj = mod for part in name.split('.'): obj = getattr(obj, part) return obj except: return None def get_url_base(app): return 'http://github.com/%s/tree/%s/' % ( app.config.edit_on_github_project, app.config.edit_on_github_branch) def doctree_read(app, doctree): # Get the configuration parameters if app.config.edit_on_github_project == 'REQUIRED': raise ValueError( "The edit_on_github_project configuration variable must be " "provided in the conf.py") source_root = app.config.edit_on_github_source_root url = get_url_base(app) docstring_message = app.config.edit_on_github_docstring_message # Handle the docstring-editing links for objnode in doctree.traverse(addnodes.desc): if objnode.get('domain') != 'py': continue names = set() for signode in objnode: if not isinstance(signode, addnodes.desc_signature): continue modname = signode.get('module') if not modname: continue fullname = signode.get('fullname') if fullname in names: # only one link per name, please continue names.add(fullname) obj = import_object(modname, fullname) anchor = None if obj is not None: try: lines, lineno = inspect.getsourcelines(obj) except: pass else: anchor = '#L%d' % lineno if anchor: real_modname = inspect.getmodule(obj).__name__ path = '%s%s%s.py%s' % ( url, source_root, real_modname.replace('.', '/'), anchor) onlynode = addnodes.only(expr='html') onlynode += nodes.reference( reftitle=app.config.edit_on_github_help_message, refuri=path) onlynode[0] += nodes.inline( '', '', nodes.raw('', ' ', format='html'), nodes.Text(docstring_message), classes=['edit-on-github', 'viewcode-link']) signode += onlynode def html_page_context(app, pagename, templatename, context, doctree): if (templatename == 'page.html' and not re.match(app.config.edit_on_github_skip_regex, pagename)): doc_root = app.config.edit_on_github_doc_root if doc_root != '' and not doc_root.endswith('/'): doc_root += '/' doc_path = os.path.relpath(doctree.get('source'), app.builder.srcdir) url = get_url_base(app) page_message = app.config.edit_on_github_page_message context['edit_on_github'] = url + doc_root + doc_path context['edit_on_github_page_message'] = page_message def setup(app): app.add_config_value('edit_on_github_project', 'REQUIRED', True) app.add_config_value('edit_on_github_branch', 'master', True) app.add_config_value('edit_on_github_source_root', 'lib', True) app.add_config_value('edit_on_github_doc_root', 'doc', True) app.add_config_value('edit_on_github_docstring_message', '[edit on github]', True) app.add_config_value('edit_on_github_page_message', 'Edit This Page on Github', True) app.add_config_value('edit_on_github_help_message', 'Push the Edit button on the next page', True) app.add_config_value('edit_on_github_skip_regex', '_.*', True) app.connect('doctree-read', doctree_read) app.connect('html-page-context', html_page_context) return {'parallel_read_safe': True, 'parallel_write_safe': True} regions-0.4/astropy_helpers/astropy_helpers/sphinx/local/0000755000076600000240000000000013501657425024145 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/sphinx/local/python2_local_links.inv0000644000076600000240000000106213336766207030644 0ustar deilstaff00000000000000# Sphinx inventory version 2 # Project: Python # Version: 2.7 and 3.5 # The remainder of this file should be compressed using zlib. xœ¥”=OÃ0@wÿŠ“ºÀà Z!¤n€U µbwœ+1ríp¶KïÇIi›”QeIä˽wþ8g³"Wf ʬÐxK%¬œ²†lS²ï(ý¦¥Ï­‰‘×Í×1 “k&ƒQrÃóp)”ÉÀ.ÀçÊÁBi—Û 3H¤]„ÎaÁ)ó_Z¥I¤‹Ú>d“H¯ï‰,ÅÐ× _M…_Âð"æ’ òbvIî—zЀ8›<ŸŒ?oÙ',O…wg¯B<•o@œÍËâdÁžá»}5ºdsµDüqã¨ÛØÄ8KK®ÂÁÈßô6úo²9 ¤«£%üè|‡¶@Ó­9ȯ]Τ52ÅvMÁ‡ØQÉCý®üR çÚò#ùunÏÑóœPdSkõýeð›]íW³¸Þ€ÉKõ쨰ɨ¥ÍdÎ RÆŸÿû¼êü_­/ªÖø“'RÉšãG4Hâ¯Õ·ØíÒÛÁ½„·ä·±fžªC{ÃÒÖß| åEª»;åö½¤-¿³ï2½ä{ÉÁÌ]iäÄÇMë;û–¨«HÏãm‹8û‹´RKregions-0.4/astropy_helpers/astropy_helpers/sphinx/local/python2_local_links.txt0000644000076600000240000000314613336766207030674 0ustar deilstaff00000000000000# Sphinx inventory version 2 # Project: Python # Version: 2.7 and 3.5 # The remainder of this file should be compressed using zlib. # python2 IndexError py:exception -1 2/library/exceptions.html#IndexError - IOError py:exception -1 2/library/exceptions.html#IOError - KeyError py:exception -1 2/library/exceptions.html#KeyError - ValueError py:exception -1 2/library/exceptions.html#ValueError - TypeError py:exception -1 2/library/exceptions.html#TypeError - # python3 only TimeoutError py:exception -1 3/library/exceptions.html#TimeoutError - bytes py:function -1 3/library/functions.html#bytes - urllib.request.urlopen py:function -1 3/library/urllib.request.html#urllib.request.urlopen - concurrent.futures.Future py:class -1 3/library/concurrent.futures.html#concurrent.futures.Future - concurrent.futures.ThreadPoolExecutor py:class -1 3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor - queue.Queue py:class -1 3/library/queue.html#queue.Queue - print() py:function -1 3/library/functions.html#print - # python3 only collections.abc collections.Generator py:class -1 3/library/collections.abc.html#collections.abc.Generator - collections.ByteString py:class -1 3/library/collections.abc.html#collections.abc.ByteString - collections.Awaitable py:class -1 3/library/collections.abc.html#collections.abc.Awaitable - collections.Coroutine py:class -1 3/library/collections.abc.html#collections.abc.Coroutine - collections.AsyncIterable py:class -1 3/library/collections.abc.html#collections.abc.AsyncIterable - collections.AsyncIterator py:class -1 3/library/collections.abc.html#collections.abc.AsyncIterator - regions-0.4/astropy_helpers/astropy_helpers/sphinx/local/python3_local_links.inv0000644000076600000240000000122213336766207030643 0ustar deilstaff00000000000000# Sphinx inventory version 2 # Project: Python # Version: 3.5 # The remainder of this file should be compressed using zlib. xœ­ÕÁŽÚ0Ð{¾b$.í!YTUâÖîa·ª*!Qq­{h\;µ¶Ù¯ïgÉšlÏÇvÆ ØV…ÔAê#jolG´N Ëdk~#÷kØ4¾0šZv]ï–Ù'`ZÀ*ûHÍ? ‹%“Z ³_H{©\aj% Gব,:‡j'õ/xU2Ï(ºjõ%­PR\Â7’(ºjÖ¥5ýJ?Àò,³ÍCÕöf…/Õ¢ëOûˆ4©µäF´±ûZszš ºouÐO“Ü ‘Ïål;ƒ”Ýð4’û¬`îç›6éyDí¼ðM…ç”AÄ-}Jwq‰!dÞj´!#âÈT·"ç Ú«hè2£oS¡žßˆ~`· “¨t8«¤²Rûwï§ÒjnKÛñcŸRxÂržŒÿ?íéèÒÉ%Ÿ+æ\ˆOb»ÓÆ ’ø3sË»£ü¿ö`„ôV¾Ò»áv@ˆ>2¥bç;!ý•I,=Whª_ÑôÉé'Ôñö™l!þ©Qó¨%Œþ^ûÓBÝ#Ô }inuüÜÂD¹#e³ªŠ\‹ž¸:ï{ø¡tuþ;‰/wx†–yó®–.–¿ !þn²X{0Bz×Þo±øH ùÏ/LúØòxA&UÝXS{ºžâ®¸™ÌÜ5šß£¸‡Ð\’ÈRBiòJFü?regions-0.4/astropy_helpers/astropy_helpers/sphinx/local/python3_local_links.txt0000644000076600000240000000540413336766207030674 0ustar deilstaff00000000000000# Sphinx inventory version 2 # Project: Python # Version: 2.7 and 3.5 # The remainder of this file should be compressed using zlib. # python2 only links cPickle py:module -1 2/library/pickle.html#module-cPickle - unicode py:function -1 2/library/functions.html#unicode - bsddb py:module -1 2/library/bsddb.html#module-bsddb - dict.has_key py:method -1 2/library/stdtypes.html#dict.has_key - dict.iteritems py:method -1 2/library/stdtypes.html#dict.iteritems - dict.iterkeys py:method -1 2/library/stdtypes.html#dict.iterkeys - dict.itervalues py:method -1 2/library/stdtypes.html#dict.itervalues - urllib2.urlopen py:function -1 2/library/urllib2.html#urllib2.urlopen - # python3 print() py:function -1 3/library/functions.html#print - # python3 collections.abc collections.Container py:class -1 3/library/collections.abc.html#collections.abc.Container - collections.Hashable py:class -1 3/library/collections.abc.html#collections.abc.Hashable - collections.Sized py:class -1 3/library/collections.abc.html#collections.abc.Sized - collections.Callable py:class -1 3/library/collections.abc.html#collections.abc.Callable - collections.Iterable py:class -1 3/library/collections.abc.html#collections.abc.Iterable - collections.Iterator py:class -1 3/library/collections.abc.html#collections.abc.Iterator - collections.Generator py:class -1 3/library/collections.abc.html#collections.abc.Generator - collections.Sequence py:class -1 3/library/collections.abc.html#collections.abc.Sequence - collections.MutableSequence py:class -1 3/library/collections.abc.html#collections.abc.MutableSequence - collections.ByteString py:class -1 3/library/collections.abc.html#collections.abc.ByteString - collections.Set py:class -1 3/library/collections.abc.html#collections.abc.Set - collections.MutableSet py:class -1 3/library/collections.abc.html#collections.abc.MutableSet - collections.Mapping py:class -1 3/library/collections.abc.html#collections.abc.Mapping - collections.MutableMapping py:class -1 3/library/collections.abc.html#collections.abc.MutableMapping - collections.MappingView py:class -1 3/library/collections.abc.html#collections.abc.MappingView - collections.ItemsView py:class -1 3/library/collections.abc.html#collections.abc.ItemsView - collections.KeysView py:class -1 3/library/collections.abc.html#collections.abc.KeysView - collections.ValuesView py:class -1 3/library/collections.abc.html#collections.abc.ValuesView - collections.Awaitable py:class -1 3/library/collections.abc.html#collections.abc.Awaitable - collections.Coroutine py:class -1 3/library/collections.abc.html#collections.abc.Coroutine - collections.AsyncIterable py:class -1 3/library/collections.abc.html#collections.abc.AsyncIterable - collections.AsyncIterator py:class -1 3/library/collections.abc.html#collections.abc.AsyncIterator - regions-0.4/astropy_helpers/astropy_helpers/sphinx/setup_package.py0000644000076600000240000000044413336766207026247 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst def get_package_data(): # Install the theme files return { 'astropy_helpers.sphinx': [ 'local/*.inv', 'themes/bootstrap-astropy/*.*', 'themes/bootstrap-astropy/static/*.*']} regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/0000755000076600000240000000000013501657425024340 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/0000755000076600000240000000000013501657425030054 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/globaltoc.html0000644000076600000240000000011113336766207032706 0ustar deilstaff00000000000000

Table of Contents

{{ toctree(maxdepth=-1, titles_only=true) }} regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/layout.html0000644000076600000240000000655113336766207032273 0ustar deilstaff00000000000000{% extends "basic/layout.html" %} {# Collapsible sidebar script from default/layout.html in Sphinx #} {% set script_files = script_files + ['_static/sidebar.js'] %} {# Add the google webfonts needed for the logo #} {% block extrahead %} {% if not embedded %}{% endif %} {% endblock %} {% block header %}
{{ theme_logotext1 }}{{ theme_logotext2 }}{{ theme_logotext3 }}
  • Index
  • Modules
  • {% block sidebarsearch %} {% include "searchbox.html" %} {% endblock %}
{% endblock %} {% block relbar1 %} {% endblock %} {# Silence the bottom relbar. #} {% block relbar2 %}{% endblock %} {%- block footer %}

{%- if edit_on_github %} {{ edit_on_github_page_message }}   {%- endif %} {%- if show_source and has_source and sourcename %} {{ _('Page Source') }} {%- endif %}   Back to Top

{%- if show_copyright %} {%- if hasdoc('copyright') %} {% trans path=pathto('copyright'), copyright=copyright|e %}© Copyright {{ copyright }}.{% endtrans %}
{%- else %} {% trans copyright=copyright|e %}© Copyright {{ copyright }}.{% endtrans %}
{%- endif %} {%- endif %} {%- if show_sphinx %} {% trans sphinx_version=sphinx_version|e %}Created using Sphinx {{ sphinx_version }}.{% endtrans %}   {%- endif %} {%- if last_updated %} {% trans last_updated=last_updated|e %}Last built {{ last_updated }}.{% endtrans %}
{%- endif %}

{%- endblock %} regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/localtoc.html0000644000076600000240000000004213336766207032543 0ustar deilstaff00000000000000

Page Contents

{{ toc }} regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/searchbox.html0000644000076600000240000000042013336766207032721 0ustar deilstaff00000000000000{%- if pagename != "search" %}
{%- endif %} regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/static/0000755000076600000240000000000013501657425031343 5ustar deilstaff00000000000000././@LongLink0000000000000000000000000000014700000000000011217 Lustar 00000000000000regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_linkout.svgregions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_linkout.s0000644000076600000240000001212113336766207034777 0ustar deilstaff00000000000000 ././@LongLink0000000000000000000000000000015200000000000011213 Lustar 00000000000000regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_linkout_20.pngregions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_linkout_20000644000076600000240000000327513336766207034771 0ustar deilstaff00000000000000‰PNG  IHDR[â8A bKGDÿÿÿ ½§“ oFFsvek pHYs × ×B(›x vpAg\@0¢Ð¬IDATXÃå˜iŒ_SÆϘÚ+Új‹fF« BH‘XbOÐέ†ª}‰-Z¤Abû¢$¤Öi…V#¸T•ZCÕ– µIi™ÚU”d¦ª÷ý›;·÷?™)Ó*OrsïyÏsÏûžçžóžs®è!ج’ôLOùÙ`[À–=é`œ3|¼±;»1`{ÛͶﱽÔv]mú«ßØÞX°=˜l¦y’Zjs„á@30ŒlÈ<,éÝ’ÆöÆ @+ð60SÒ϶ûÇG½í‰ñü¡¤mo œ¬‘t—íþÀ%À `¶¤4üÔ pÐX<,’Ô1¦„:`•R~qÂPà` ð.°0kœÐ¨WJéŒs¶@R>)é÷ÎÀ´Ntž$éS`6p6pTØím¢5…—ÿÆHš“s8˜Éã{à@`»¿ ÷J:×v=ð%``/à9`çàœ/iší~À\`ÿbŸ{ƒçœH7KBäÝ€§"Æ“o€f¥´:¡/°hRÊʱ' J™\"ö`ànàÜ*ý[!©ÍöåÀ”ˆÿ `'I­ØÆö¶µ}Ÿí ¶o´Ý9÷#Ûg›Ùþ6ì l²}’í—m¿h[¶›lO·ýeð~ŽòtÛgE;õnÇÛkmϳ=Ëö^ÑÎKQ¿&âš~*¸² Ò NøÑ §ìµNxÊ ×æl30¡L-'ÌwÂ~¥uö ÛOÒ lOŒ˜Ïm)†ÙÞ©`»"×±ÁakÈÙšs\"5äߟ[m,ˆÝfû˜Bý±¹ú 9{ígÃþ[Œþ¼Ø“ªØà„'(Ê8á}'ëðú;aqÑ^{N•:l_q-ãÔHZ"éëx©.„Ü5ÇkŠû×ÀOñ|[ì86—„¤_Y?Ü-éé‚í¸¸ÿB6m‰8×wDqkÚ×… ÚÊ(eY´5$ʯwdz"ðD%¿—iZMh²´1/éѪbÛîmûZÛŸ‘åÒ¸0Çë] ŒV’-Ž_Ù¾9öÕ냲…ª1îK%­)Ôå®AÝðÓBûº08­À9•lî *±íN¶à'’ž M/ÎØÛÛo×;·GcJ=IÏÛ€€þÀeÀ›¶û®§àÕ:T6’܆ò}ÖæÊ³€£œP à„F 7°¸“6J}Kú h,ÌÐa¡S‡ÎŒŠV`¤¤‹%½üXU é[I—»WEÀÿˆÔ°<îM¶‹;¤Á¹çeÝh³1ÏWÊjà% 2úF3;I!±ËF6’Z ¦âÇ¥†ÈcÀrIKªtªÝ›=¢"€¤VIS€rªà·¸°½Y7Å®ï·ÎÈù8/ŠmÀü®4æ„}Õdg‡<¦çÄóhàÁ.4§.p*Úv»ø*žw·}=YJ9ÖÝÙ¼,²=øì”…9ú;À @_`†í¹ÀÊ.þ'IÉöê#{lï |Hv868·Hú¦ðÞÞNRòûï-ÈRãÍ%£öM Þ ûµJÿšQÕÐVCvNé öŒ¶¸&ìk"À“ÉrrÉv$Ä•Ç:ŽŒidi¥8%®WiµU!i­íÑÀcáçÒ\õÀý¹XóÌsÂL²…w7`2°¸o?)8áNàqàÖ.ŠØd{rxS˜yÙ¾ÓÞ¸˜,¡¯î—ôží1À²³ýòàöŽúß‘”æåOtÁ\ V $MSë©A{UÒGeÑFºj&;öö#›IIZg‹dK| ó€=ÉÆJYTM'lE¶»¤”–ÎÔ‹³Äé]ü(¯Hú üMq¨¹h=ÞÛÏ ¯lˆkþ~›<&wmGÿk±pYº™½!üõäÿì%âÿÈ#ÀædëÀX¥·h=…ÿ’ØSß»À3p5™Ø‹óÛĞƟ ½§pÅ%tEXtdate:create2012-10-18T20:57:33+02:00¢p_f%tEXtdate:modify2012-10-18T20:57:33+02:00Ó-çÚtEXtSoftwarewww.inkscape.org›î<IEND®B`‚regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_logo.ico0000644000076600000240000010033413336766207034566 0ustar deilstaff00000000000000@@ (@F  (n@ ( –P (¾Y(@€ ÿÿ ÿ* ÿVýy ý›¬±ûÕúûüí÷ùüìýýýíýýýí§ªû× ü«ý‹ýoüKÿ ÿ ÿÿîûHýýÌúìýó ûøûü°µÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ˜Ÿÿÿûþ ûúûöýòúéûÇýÿIóÿ¿ÿ!ýyûÏüðüúÿÿÿÿÿÿ ÿÿ>KÿÿÏÓÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ‡ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿûúÿðûÚü—û?ã ÿÿý|ûÚýöÿÿÿÿÿÿþÿýÿýÿLYþÿÌÏÿÿûüÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþÿÿerþÿýÿýÿýÿýÿýÿþÿÿÿÿÿÿÿüûûíú½ÿZÿÿüJûÇýöÿÿÿÿþÿýÿýÿýÿ*<þÿ™¡ÿÿêíÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÉÎÿÿ3Eýÿ ýÿýÿýÿýÿýÿýÿýÿýÿþÿÿÿÿÿÿÿÿðûÄüXÿÿü•üêÿÿÿÿþÿýÿýÿýÿ1ýÿ“þÿäèÿÿûûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿrþÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿÿÿÿÿÿÿüïù´ÿ=ÿø$û®ýúÿÿÿÿýÿýÿýÿýÿ.Cþÿ·¿ÿÿùúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ”Ÿþÿ*ýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿÿÿÿÿÿÿúâû†ÿÿ3üÃüþÿÿýÿýÿýÿýÿýÿ^pþÿÓÙÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ÷øÿÿ…“þÿ+ýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿÿÿÿÿýöü¸ÿ7 ÿ(øÃ!ÿÿ ÿÿ ýÿ ýÿ ýÿýÿýÿsƒþÿåéÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÅÍþÿPfýÿ %ýÿýÿýÿ ýÿ ýÿ ýÿ ýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿþÿÿÿ ÿÿûÙ ÿi#ÿ úº#ÿÿ"ÿÿ"ýÿ"ýÿ"ýÿ ýÿ ýÿy‹ÿÿîðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâåþÿu‡ýÿ =ýÿýÿýÿ!ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ!ýÿ!ÿÿ!ÿÿ ûìýƒÿÿ$ý›$ýÿ$ÿÿ$ýÿ$ýÿ$ýÿ"ýÿýÿmþÿëîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýýÿÿ¦²þÿ8Týÿ%ýÿýÿ!ýÿ$ýÿ$ýÿ$ýÿ$ýÿ$ýÿ#ýÿ#ýÿ#ýÿ"ýÿ"ýÿ"ýÿ"ýÿ#ýÿ#ýÿ#ýÿ$ýÿ$ýÿ$ýÿ$ýÿ$ýÿ$ýÿ#ýÿ#ýÿ$þÿ$ÿÿ#üõ!ü’'ÿ &ÿj'ûñ(ÿÿ&ýÿ&ýÿ&ýÿ&ýÿ!ýÿNiþÿÞãÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿçëþÿmƒýÿ5ýÿ ýÿ ýÿ%ýÿ&ýÿ&ýÿ&ýÿ%ýÿ%ýÿ$ýÿ#ýÿ#ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ"ýÿ#ýÿ#ýÿ$ýÿ$ýÿ%ýÿ&ýÿ&ýÿ&ýÿ&ýÿ&ýÿ&ýÿ&þÿ&ÿÿ%ýø&üš3ÿ)ÿ%(ûØ*ÿÿ)ýÿ)ýÿ)ýÿ(ýÿ%ýÿ'IþÿÇÐÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÙßþÿUqýÿ'ýÿ!ýÿ'ýÿ)ýÿ(ýÿ(ýÿ(ýÿ'ýÿ&ýÿ#ýÿ(ýÿ"DþÿPkþÿp†þÿ‡™þÿ’£þÿ‘¢þÿ„˜þÿm„þÿNjþÿ!Cþÿ&ýÿ"ýÿ%ýÿ&ýÿ'ýÿ(ýÿ(ýÿ(ýÿ(ýÿ(ýÿ(ýÿ(ÿÿ&üú'ü˜9ÿ ÿ+ý”*þÿ+ÿÿ*þÿ+þÿ+þÿ)þÿ*þÿ®ÿÿþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿàåÿÿQoþÿ%þÿ%þÿ+þÿ+þÿ+þÿ+þÿ*þÿ'þÿ$þÿ"Gþÿt‹ÿÿ¶ÂÿÿÔÛÿÿäèÿÿïñÿÿöøÿÿúûÿÿúûÿÿö÷ÿÿîñÿÿãèÿÿÔÛÿÿ¹Åÿÿ}’ÿÿ/Rþÿ'þÿ&þÿ)þÿ)þÿ*þÿ*þÿ*þÿ*þÿ*þÿ*ÿÿ'ûù'ý‰Uª+ÿ;-üæ.ÿÿ-þÿ-þÿ-þÿ,þÿ)þÿVtÿÿêîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿíñÿÿ]zþÿ(þÿ'þÿ-þÿ-þÿ-þÿ-þÿ,þÿ$þÿFþÿ‰ÿÿÒÚÿÿðóÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿóõÿÿ×Þÿÿ£³ÿÿ?`ÿÿ)þÿ)þÿ,þÿ,þÿ,þÿ,þÿ,þÿ,þÿ.ÿÿ,üñ.ýt@ÿ/ý™/þÿ0ÿÿ0þÿ0þÿ0þÿ-þÿ :þÿ¿Ìÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿz“þÿ1þÿ(þÿ0þÿ/þÿ.þÿ/þÿ,þÿ+þÿZwÿÿÇÑÿÿøúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÜâÿÿ”§ÿÿ#Lþÿ'þÿ.þÿ/þÿ/þÿ/þÿ/þÿ/þÿ0ÿÿ.üâ-ÿI0ÿ%0ýá2ÿÿ1þÿ1þÿ1þÿ0þÿ/þÿbÿÿðóÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¯¿þÿHþÿ)þÿ1þÿ2þÿ2þÿ1þÿ.þÿ8þÿx’ÿÿæëÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüýÿÿÄÏÿÿTsÿÿ+þÿ/þÿ1þÿ0þÿ0þÿ0þÿ1ÿÿ1ÿÿ/üÈ2ÿ$@¿3ýn3üø5ÿÿ3þÿ3þÿ3þÿ1þÿ8þÿÀÌÿÿþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿëïÿÿEkþÿ,þÿ2þÿ4þÿ3þÿ4þÿ1þÿ8þÿ€šÿÿñôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôöÿÿÕÞÿÿËÕÿÿËÖÿÿ×ßÿÿõöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâçÿÿqÿÿ1þÿ0þÿ3þÿ2þÿ2þÿ2þÿ3ÿÿ2þÿ0üŸ@ÿã 2ü¶6üþ6ÿÿ6þÿ6þÿ5þÿ5þÿDlþÿèíÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ”«þÿ @þÿ/þÿ6þÿ5þÿ5þÿ4þÿ0þÿt‘ÿÿñôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿäéÿÿ—­þÿ\~þÿ?eþÿ1\þÿ,Xþÿ,Xþÿ2]þÿ?fþÿZ}þÿ§þÿÖßÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿïòÿÿu’ÿÿ3þÿ3þÿ5þÿ5þÿ5þÿ5þÿ6ÿÿ4üð4ÿX8ÿ 5ûå:ÿÿ8þÿ8þÿ8þÿ7þÿ7þÿ–®ÿÿûüÿÿÿÿÿÿÿÿÿÿÿÿÿÿðôÿÿ@jþÿ0þÿ8þÿ8þÿ8þÿ8þÿ.þÿRxÿÿæëÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿñóÿÿާþÿ:eþÿEþÿ1þÿ*þÿ-þÿ.þÿ.þÿ-þÿ*þÿ0þÿCþÿ3]þÿj‹þÿËÖþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿíòÿÿlŒÿÿ1þÿ6þÿ8þÿ7þÿ7þÿ8þÿ8ÿÿ5ýÌ5ÿ:ÿO9üô<ÿÿ:þÿ:þÿ:þÿ8þÿ BþÿÏÚÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ®ÁþÿMþÿ3þÿ;þÿ:þÿ;þÿ7þÿOþÿ»ËÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÕÞþÿ^„þÿ@þÿ/þÿ4þÿ9þÿ:þÿ:þÿ:þÿ9þÿ9þÿ9þÿ8þÿ4þÿ.þÿ6þÿ/]þÿ‹¥þÿóõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿàçÿÿMuÿÿ3þÿ9þÿ9þÿ9þÿ9þÿ;ÿÿ8ûý8ÿÿ<ÿ{;ü÷=ÿÿ<þÿ<þÿ<þÿ;þÿ9hþÿæìÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿcˆþÿ<þÿ:þÿ<þÿ<þÿ<þÿ2þÿx™ÿÿõøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÒÝþÿOyþÿ6þÿ5þÿ<þÿ=þÿ<þÿ<þÿ<þÿ<þÿ<þÿ<þÿ<þÿ<þÿ<þÿ<þÿ9þÿ2þÿ Aþÿf‹þÿàçÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÅÓÿÿ!Sþÿ9þÿ;þÿ;þÿ;þÿ<þÿ=ÿÿ9üÝ;ÿ'=ý¢?ûý@ÿÿ?þÿ?þÿ=þÿ?þÿkÿÿðôÿÿÿÿÿÿÿÿÿÿÿÿÿÿñôÿÿ7gþÿ5þÿ>þÿ>þÿ>þÿ;þÿMþÿ¾Îÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿêïÿÿc‰þÿ8þÿ9þÿ?þÿ>þÿ>þÿ>þÿ>þÿ>þÿ>þÿ>þÿ>þÿ>þÿ>þÿ>þÿ>þÿ?þÿ>þÿ7þÿ:þÿ[„þÿàèÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüýÿÿ‘¬ÿÿ=þÿ<þÿ>þÿ>þÿ>þÿ@ÿÿ>üþ>ýˆÿAþ¿BÿÿBÿÿAþÿAþÿ?þÿBþÿ•°ÿÿúüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÉ×ÿÿ#[þÿ9þÿAþÿAþÿAþÿ:þÿUÿÿäëÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ”°þÿ Fþÿ9þÿAþÿ@þÿ@þÿ@þÿ>þÿ:þÿ6þÿ5þÿ5þÿ7þÿ;þÿ?þÿ@þÿ@þÿ@þÿ@þÿAþÿ;þÿ=þÿeþÿñõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãëÿÿ>oþÿ>þÿ@þÿ@þÿ@þÿAþÿBÿÿ?üÝ<ÿBûÒDÿÿCÿÿCþÿCþÿAþÿDþÿ³Çÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¢ºþÿTþÿ>þÿCþÿCþÿCþÿ9þÿŒ«ÿÿûýÿÿÿÿÿÿÿÿÿÿÿÿÿÿâêÿÿEvþÿ7þÿCþÿCþÿCþÿ>þÿ4þÿDþÿBsþÿs˜þÿƒ£ÿÿ„£ÿÿjÿÿ0fþÿ>þÿ:þÿBþÿBþÿBþÿBþÿCþÿ;þÿ Fþÿˆ¦þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüýÿÿ§¾ÿÿCþÿ@þÿBþÿBþÿBþÿDÿÿBûúBýhUÿEûãGÿÿEþÿEþÿEþÿBþÿFþÿÈÖÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ‡¨þÿOþÿAþÿEþÿEþÿDþÿ@þÿ®Äÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ©ÁþÿYþÿ?þÿFþÿCþÿ9þÿ&aþÿ¡ÿÿ¨ÀÿÿÔàÿÿöùÿÿÿÿÿÿÿÿÿÿïóÿÿÈÖÿÿ—³ÿÿ?rÿÿ?þÿBþÿEþÿEþÿEþÿEþÿ=þÿ$_þÿÇÖþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâêÿÿ4kþÿCþÿDþÿDþÿDþÿDÿÿEýþBüÄ@ÿ FúêJÿÿHþÿHþÿHþÿEþÿIþÿÕáÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿxžþÿMþÿDþÿGþÿGþÿFþÿ Oþÿ¾Ðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ‚¥þÿIþÿEþÿ?þÿHþÿ_Šÿÿ¿ÑÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÒßÿÿbŽÿÿHþÿEþÿGþÿGþÿGþÿEþÿEþÿ\‰þÿþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿùûÿÿ‰ªÿÿEþÿEþÿGþÿGþÿGþÿIÿÿDûñJÿ4IûåLÿÿJþÿJþÿJþÿGþÿLþÿÙäÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿtœþÿNþÿGþÿJþÿJþÿHþÿZþÿÃÕÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿp™þÿBþÿ=þÿ ]ÿÿЬÿÿêðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿèïÿÿ]ŒÿÿBþÿIþÿIþÿIþÿJþÿAþÿ `þÿÆ×þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿËÚÿÿ PþÿGþÿIþÿIþÿIþÿKÿÿHüùJÿxLúàNÿÿLÿÿLþÿLþÿIþÿNþÿÖãÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ{¢þÿ RþÿIþÿLþÿLþÿJþÿ\þÿÃÕÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿrœþÿ;þÿ.hÿÿ¬ÄÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿËÛÿÿ+iÿÿGþÿKþÿKþÿKþÿHþÿNþÿo™þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿçîÿÿ5pþÿJþÿKþÿKþÿKþÿKÿÿKüþLü¿OûÓPÿÿNÿÿNþÿNþÿLþÿOþÿÈÙÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ°þÿYþÿJþÿNþÿNþÿMþÿRþÿ¼Ðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€¦þÿ5nÿÿ®ÈÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøûÿÿŠ®ÿÿFþÿMþÿNþÿNþÿNþÿFþÿ9uþÿô÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿðõÿÿnšÿÿMþÿKþÿMþÿMþÿMþÿOÿÿLûéPüºQþÿQÿÿQþÿQþÿOþÿRþÿ±Éÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¬ÆÿÿbþÿJþÿPþÿPþÿPþÿHþÿ¨ÃÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿºÏÿÿ¹ÐÿÿüýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÀÕÿÿ\þÿNþÿPþÿPþÿPþÿIþÿ!gþÿÈÙÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýÿÿ™¹ÿÿPþÿNþÿPþÿPþÿPþÿRÿÿPüïRýŸQüüTÿÿSþÿSþÿQþÿTþÿ‘µÿÿùûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÚæÿÿ'mþÿJþÿSþÿSþÿSþÿJþÿ}§ÿÿõøÿÿÿÿÿÿÿÿÿÿÿÿÿÿ÷ùÿÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûüÿÿüýÿÿÿÿÿÿÿÿÿÿÿÿÿÿØäÿÿAÿÿNþÿRþÿRþÿRþÿMþÿ`þÿ›¼þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿºÐÿÿTþÿPþÿRþÿRþÿRþÿTÿÿPüíVÿ}UüøVÿÿUþÿUþÿSþÿTþÿf™ÿÿïôÿÿÿÿÿÿÿÿÿÿÿÿÿÿûýÿÿF„þÿOþÿTþÿUþÿUþÿQþÿ9{ÿÿØåÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÑàÿÿœ½ÿÿéðÿÿÿÿÿÿÿÿÿÿÿÿÿÿæîÿÿ_“ÿÿNþÿTþÿTþÿTþÿPþÿ Zþÿ~¨þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÑàÿÿVþÿQþÿTþÿTþÿTþÿVÿÿRüíVÿPWüóYÿÿWþÿWþÿVþÿUþÿ0wþÿåîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿˆ±þÿ _þÿSþÿWþÿWþÿVþÿXþÿ¡ÁÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿçïÿÿSÿÿ:}þÿÖäÿÿÿÿÿÿÿÿÿÿÿÿÿÿìóÿÿjÿÿPþÿVþÿVþÿVþÿTþÿYþÿjœþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÛçÿÿ ]þÿSþÿVþÿVþÿVþÿXÿÿVüíZÿ"Xúì\ÿÿYþÿYþÿYþÿWþÿ^þÿÃÙÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÜéÿÿ-vþÿQþÿYþÿYþÿYþÿRþÿ;€ÿÿÙæÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßêÿÿb™ÿÿQþÿ9þÿÛèÿÿÿÿÿÿÿÿÿÿÿÿÿÿëòÿÿhœÿÿSþÿYþÿYþÿYþÿWþÿZþÿb™þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞéÿÿeþÿWþÿXþÿXþÿXþÿ[ÿÿXüífÿ XüÇ]ýþ\ÿÿ\þÿ\þÿZþÿZþÿ~¬ÿÿ÷úÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿzªþÿ^þÿWþÿ\þÿ[þÿ[þÿWþÿd›ÿÿêòÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¿×ÿÿOÿÿXþÿKþÿNŽþÿó÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿáìÿÿV’ÿÿVþÿ[þÿ[þÿ[þÿYþÿ\þÿeœþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÝéÿÿ dþÿYþÿ[þÿ[þÿ[þÿ^ÿÿ[üífÿ_ý„]üù_ÿÿ^þÿ^þÿ]þÿ\þÿ*xþÿÜèÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿàëÿÿ<„þÿXþÿ]þÿ^þÿ^þÿ\þÿ_þÿdÿÿÓäÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÑâÿÿ‡³ÿÿ)wÿÿTþÿ[þÿYþÿt§þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÒâÿÿ4þÿYþÿ]þÿ]þÿ]þÿZþÿaþÿr¥þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÙçÿÿ`þÿZþÿ]þÿ]þÿ]þÿ`ÿÿ]üíÿbÿ<`ûñcÿÿ`þÿ`þÿ`þÿ^þÿ]þÿ˜¿ÿÿûýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ®ÌþÿoþÿYþÿ`þÿ`þÿ`þÿ]þÿ[þÿBˆÿÿ—¾ÿÿÏáÿÿøúÿÿÿÿÿÿüýÿÿäîÿÿ´Ðÿÿ‹·ÿÿ?‡ÿÿZþÿYþÿ`þÿWþÿ"vþÿ½Õþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¹Óÿÿeþÿ]þÿ_þÿ_þÿ_þÿ\þÿhþÿеþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÈÜÿÿ`þÿ\þÿ_þÿ_þÿ_þÿbÿÿ]üímíbýÌdýþbþÿbþÿbþÿbþÿaþÿ/€þÿÚèÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ‘»þÿiþÿ[þÿaþÿbþÿbþÿaþÿZþÿ_þÿ;†þÿr¨ÿÿ°ÿÿy¬ÿÿW—þÿoþÿWþÿ[þÿaþÿbþÿ_þÿ]þÿp§þÿøûÿÿÿÿÿÿÿÿÿÿÿÿÿÿùûÿÿ‰·ÿÿYþÿaþÿbþÿbþÿbþÿ]þÿrþÿ¬Ìþÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿÿ­Ìÿÿbþÿ_þÿaþÿaþÿaþÿdÿÿ_üíUªeýwdüùgÿÿeþÿeþÿeþÿdþÿ`þÿy®ÿÿùûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþÿÿºþÿoþÿ\þÿbþÿdþÿdþÿdþÿcþÿ_þÿZþÿYþÿZþÿ\þÿaþÿdþÿdþÿdþÿaþÿ]þÿGþÿÔäþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿØçÿÿ9‡ÿÿ_þÿdþÿdþÿdþÿdþÿ\þÿ(|þÿÜêÿÿÿÿÿÿÿÿÿÿÿÿÿÿ÷ûÿÿ‰·ÿÿeþÿbþÿdþÿdþÿdþÿgÿÿdüígÿ%füâjÿÿgþÿgþÿgþÿgþÿeþÿpþÿ°Ïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ Æþÿ3…þÿcþÿ_þÿfþÿgþÿgþÿgþÿfþÿfþÿfþÿfþÿfþÿfþÿfþÿ_þÿcþÿG‘þÿÆÝþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüýÿÿ˜Áÿÿcþÿeþÿfþÿfþÿfþÿeþÿ`þÿGþÿþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿìôÿÿZ›þÿeþÿeþÿfþÿfþÿfþÿiÿÿfüíÿiý—hýýkÿÿiþÿiþÿiþÿhþÿeþÿ5‡þÿÍáÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿËáþÿg¥þÿ'}þÿeþÿ`þÿdþÿfþÿgþÿhþÿhþÿgþÿeþÿaþÿbþÿwþÿj§þÿØèþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÐäÿÿ5‡ÿÿcþÿhþÿhþÿhþÿhþÿdþÿ pþÿ‰¹þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿàíÿÿ&þÿfþÿgþÿhþÿhþÿhþÿkÿÿhüíjÿ0kúánÿÿkþÿkþÿkþÿkþÿjþÿeþÿN˜ÿÿ×éÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¹Öþÿi¨þÿ=þÿ|þÿ qþÿhþÿdþÿfþÿlþÿvþÿ0…þÿXžþÿ«Îþÿüýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿïöÿÿd¦ÿÿdþÿjþÿkþÿkþÿkþÿkþÿdþÿ*„þÿØéÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿÿ¼ØÿÿkþÿhþÿjþÿjþÿjþÿjþÿmÿÿküínýmüþpÿÿnþÿnþÿnþÿnþÿmþÿgþÿSœÿÿÑåÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿáîÿÿ«Ïþÿ‡ºþÿmªþÿ_¤þÿe§þÿx±þÿ˜ÃþÿÊáÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿòøÿÿ|µÿÿnþÿkþÿmþÿmþÿmþÿmþÿjþÿmþÿl«þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôùÿÿq®ÿÿlþÿlþÿmþÿmþÿmþÿmþÿpÿÿküïuÿ%mýÔrÿÿpþÿpþÿpþÿpþÿpþÿoþÿiþÿD•ÿÿ·×ÿÿûýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿìôÿÿ~·ÿÿ tþÿkþÿoþÿoþÿnþÿjþÿkþÿiþÿ.‰þÿÒåÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÙêÿÿ#‚þÿmþÿnþÿoþÿoþÿoþÿoþÿrÿÿoüérÿgpûôuÿÿqþÿrþÿrþÿrþÿrþÿqþÿlþÿþÿÁÿÿáîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÕèÿÿj¬ÿÿsþÿoþÿqþÿqþÿpþÿsþÿ~þÿtþÿtþÿ¿þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüýÿÿ•ÄÿÿnþÿoþÿqþÿqþÿqþÿqþÿqÿÿrýþnüÂ`ÿtü«vÿÿuÿÿtþÿtþÿtþÿtþÿtþÿtþÿqþÿsþÿR ÿÿ²Õÿÿãðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâïÿÿ§Ïÿÿ:“ÿÿoþÿrþÿtþÿtþÿtþÿmþÿ%ˆþÿ—Æþÿn°þÿb©þÿóøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÜìÿÿ0þÿrþÿrþÿsþÿsþÿsþÿsþÿuÿÿsüúrýyxÿ1výÓzÿÿwþÿwþÿwþÿwþÿwþÿwþÿvþÿuþÿpþÿ {þÿW¤ÿÿ©ÒÿÿÑæÿÿëôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿð÷ÿÿÔèÿÿ«ÑÿÿT¢ÿÿxþÿqþÿuþÿuþÿuþÿvþÿsþÿ vþÿp²þÿÿÿÿÿï÷ÿÿåñÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüýÿÿ‰Àÿÿsþÿuþÿvþÿvþÿvþÿvþÿvþÿyÿÿuüéwÿ/xÿ[wûê|ÿÿyþÿxþÿxþÿxþÿxþÿyþÿyþÿxþÿwþÿtþÿvþÿ+þÿh°ÿÿ›Êÿÿ¼ÜÿÿÊãÿÿÒçÿÿÔèÿÿÒèÿÿÍåÿÿÃàÿÿ§Ñÿÿt¶ÿÿ2“þÿwþÿsþÿwþÿxþÿxþÿxþÿxþÿxþÿqþÿ7”þÿÙëÿÿÿÿÿÿÿÿÿÿýÿÿÿýþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÃßÿÿ…þÿvþÿxþÿxþÿwþÿwþÿwþÿyÿÿxÿÿwüª’ÿ|û„xûù~ÿÿ{þÿzþÿzþÿzþÿzþÿzþÿzþÿzþÿzþÿzþÿxþÿwþÿuþÿxþÿ…þÿ)þÿ-’þÿ)þÿŠþÿ|þÿuþÿwþÿxþÿzþÿzþÿzþÿ{þÿ{þÿ{þÿ{þÿvþÿ €þÿ‰ÁþÿþþÿÿÿÿÿÿÿÿÿÿþþÿÿúüÿÿþÿÿÿÿÿÿÿÝíÿÿO¤ÿÿvþÿyþÿyþÿyþÿyþÿyþÿzþÿ|ÿÿwûï|ÿHÿŽÿ {ü—~ýú€ÿÿ}þÿ}þÿ}þÿ}þÿ|þÿ|þÿ|þÿ|þÿ|þÿ|þÿ|þÿ|þÿ{þÿ{þÿ{þÿzþÿ{þÿ{þÿ{þÿ|þÿ|þÿ|þÿ|þÿ|þÿ|þÿ|þÿ|þÿ|þÿ|þÿwþÿP¥þÿôùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþÿÿýþÿÿõúÿÿ†Áÿÿyþÿ{þÿ}þÿ|þÿ|þÿ|þÿ|þÿ}ÿÿ}ÿÿzû«’ÿ€ÿ€ý¢‚ýýƒÿÿ€þÿþÿþÿþÿþÿþÿþÿþÿþÿþÿþÿþÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿyþÿ!þÿ«ÕþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿëõÿÿÀþÿ„þÿ}þÿ~þÿ~þÿ~þÿ~þÿþÿ‚ÿÿ~ûä}ÿ7„ÿú¨ƒüû…ÿÿ‚ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿ}ÿÿb±ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüþÿÿ¿ßÿÿ/˜ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿƒÿÿ€ýùý€ÿ€ÿüž…üù‡ÿÿ„ÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿƒÿÿ‚ÿÿ„ÿÿn¹ÿÿúýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿòùÿÿÇäÿÿšÎÿÿ; ÿÿƒÿÿƒÿÿƒÿÿƒÿÿ‚ÿÿ…ÿÿ…ÿÿ€ü²ˆÿ’ÿ…ý’„üòŠÿÿ‡ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿƒÿÿ‚ÿÿÿÿ€ÿÿ‚ÿÿ]±ÿÿåóÿÿùýÿÿÿÿÿÿÿÿÿÿàðÿÿ¼àÿÿƒÄÿÿ“ÿÿƒÿÿ„ÿÿ…ÿÿ…ÿÿ…ÿÿ…ÿÿ†ÿÿˆÿÿ‚ýÌ‚ÿ+€ÿ‰ýu‰üáŒÿÿŠÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‰ÿÿ‘ÿÿ•ÿÿ •ÿÿ%–ÿÿg¸ÿÿËçÿÿ³Ûÿÿ¬ØÿÿÕëÿÿ©ÖÿÿL«ÿÿ‰ÿÿ…ÿÿ†ÿÿ†ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‰ÿÿŒÿÿ†ýÔ‡ÿ@‹üMˆüÈüûŽÿÿ‹ÿÿŠÿÿŠÿÿŠÿÿŠÿÿŠÿÿŠÿÿŠÿÿŠÿÿŠÿÿŠÿÿ‰ÿÿ‰ÿÿ‰ÿÿ‰ÿÿ†ÿÿ•ÿÿxÁÿÿ«Øÿÿ¦ÖÿÿÓêÿÿëöÿÿs¾ÿÿ‰ÿÿ’ÿÿ&›ÿÿˆÿÿˆÿÿˆÿÿˆÿÿ‰ÿÿ‰ÿÿ‰ÿÿ‰ÿÿ‰ÿÿ‹ÿÿŽÿÿ‰ýÔˆÿGŠÿ#Šý™‹üìÿÿÿÿÿÿŒÿÿŒÿÿŒÿÿŒÿÿŒÿÿŒÿÿŒÿÿŒÿÿŒÿÿŒÿÿŒÿÿŒÿÿŠÿÿ•ÿÿV³ÿÿsÀÿÿ]¶ÿÿµÝÿÿ´Ýÿÿ‰ÿÿŠÿÿ‹ÿÿŠÿÿŠÿÿ‹ÿÿ‹ÿÿ‹ÿÿ‹ÿÿ‹ÿÿ‹ÿÿŒÿÿÿÿýþ‰üÆŒÿ<€ÿÿTŽüÇýó‘ÿÿ‘ÿÿÿÿŽÿÿŽÿÿŽÿÿŽÿÿŽÿÿŽÿÿŽÿÿŽÿÿŽÿÿŽÿÿŽÿÿŽÿÿÿÿÿÿ”ÿÿ‘Îÿÿ–Ñÿÿ†ÿÿŽÿÿŽÿÿŽÿÿŽÿÿŽÿÿŽÿÿŽÿÿŽÿÿŽÿÿÿÿ’ÿÿŽýóŽþ­Šÿ%ŒÿÿqŒýÔýõ“ÿÿ”ÿÿ‘ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ‹ÿÿžÿÿ’ÐÿÿsÁÿÿ‹ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ’ÿÿ”ÿÿ’ýûüÜýs€ê €ÿ™ÿ”ÿw‘ýÒ“ÿð“ÿÿ—ÿÿ–ÿÿ”ÿÿ“ÿÿ“ÿÿ’ÿÿ’ÿÿ’ÿÿ’ÿÿ’ÿÿ’ÿÿÿÿœÿÿP´ÿÿ7ªÿÿÿÿ’ÿÿ’ÿÿ’ÿÿ’ÿÿ“ÿÿ•ÿÿ–ÿÿ”ýûüç‘ýœ•ÿ0€ÿªÿ”ÿ˜ÿW“þµ”üè–ýô”ýþ™ÿÿ™ÿÿ˜ÿÿ—ÿÿ–ÿÿ–ÿÿ–ÿÿ•ÿÿ•ÿÿ•ÿÿ–ÿÿ–ÿÿ–ÿÿ—ÿÿ˜ÿÿ™ÿÿ˜ÿÿ”þÿ•ýó’úâ“ýš”ÿ7™ÿÿÿŽÿ šÿ&—ýi˜ü¯–üà˜ýï•ýõ•ýú–ýþ™ÿÿšÿÿ›ÿÿœÿÿ›ÿÿ™ÿÿ™ÿÿ˜ÿÿ—ýû•ý÷™ÿð—úâ—þ°–ÿd‘ÿªÿªÿ™æ ™ÿ›ÿ8™ÿi—ýŽšþ«—üÇ—ûØ—üá—üê•ýè˜ûÚ™ýΘþ¹™ý˜›ÿu˜ÿE›ÿ™ÿ €ÿ( @ ÿüdýŸüÁþþÿÿÿÿÿÿ¢¦ûíþº ýšüW ÿÿ,þ«úûýÿýÿuþÿÿÿÿÿÿÿÿÿ‰þÿýÿýÿýÿúüüÀüJÿÿý‡úûýÿýÿ>Pýÿ½Ãþÿÿÿÿÿÿÿÿÿúúÿÿ&:ýÿýÿýÿýÿýÿýÿýÿýÍüKÿ þºýÿýÿýÿbsþÿýýÿÿÿÿÿÿÿÿÿÿúûÿÿ\nþÿýÿýÿýÿýÿýÿýÿýÿýÿýÿý¦ ÿ+ÿþ»!ýÿ!ýÿ!ýÿŠ™þÿÿÿÿÿÿÿÿÿôöÿÿÈÏÿÿ0Jýÿ ýÿ ýÿ ýÿ ýÿ ýÿ ýÿ ýÿ ýÿ ýÿ ýÿ ýÿüÛÿ+%ý‹%ýÿ%ýÿ%ýÿp…þÿÿÿÿÿÿÿÿÿúûÿÿs‡þÿ(ýÿ%ýÿ%ýÿ%ýÿ%ýÿ%ýÿ%ýÿ%ýÿ%ýÿ%ýÿ%ýÿ%ýÿ$ýÿ$ýÿ$úí"ÿ5+ÿ0*úý*ýÿ*ýÿ>^ýÿüüÿÿÿÿÿÿõ÷ÿÿ@_ýÿ)ýÿ)ýÿ)ýÿ)ýÿ$Gýÿyþÿ¥³þÿ»Æþÿ¯¼þÿ¢þÿPlþÿ 1ýÿ)ýÿ)ýÿ)ýÿ)ýÿ)úð'ÿ..þ¶.þÿ.þÿ0þÿÌÕÿÿÿÿÿÿþþÿÿXvþÿ.þÿ.þÿ.þÿCþÿ²Àÿÿþþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿêîÿÿ{’þÿ3þÿ-þÿ-þÿ-þÿ*üÞ$ÿ3ÿ#3ûþ3þÿ3þÿXyþÿÿÿÿÿÿÿÿÿ¤¶ÿÿ2þÿ2þÿ2þÿ8_þÿìðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÍ×ÿÿ#Nþÿ2þÿ2þÿ2þÿ2ýž7ÿt7þÿ7þÿ7þÿ·ÇÿÿÿÿÿÿúûÿÿOþÿ7þÿ7þÿOþÿèíÿÿÿÿÿÿÿÿÿÿÓÜÿÿ`‚þÿKþÿ6þÿ =þÿ;eþÿ§ÿÿóöÿÿÿÿÿÿÿÿÿÿàçÿÿJþÿ6þÿ6þÿ6þÿ7ÿO:þ³<þÿ;þÿIþÿúûÿÿÿÿÿÿ¸Èÿÿ;þÿ;þÿ;þÿ¯Âÿÿÿÿÿÿÿÿÿÿ¡·ÿÿ@þÿ;þÿ;þÿ;þÿ;þÿ;þÿ;þÿPþÿÀÏÿÿÿÿÿÿÿÿÿÿÎÙÿÿ@þÿ;þÿ:þÿ:üÛUÿ@üÞ@þÿ@þÿCrþÿÿÿÿÿÿÿÿÿjþÿ@þÿ@þÿ(^þÿýýÿÿÿÿÿÿÇÕÿÿCþÿ?þÿ?þÿ?þÿ?þÿ?þÿ?þÿ?þÿ?þÿ FþÿÅÓÿÿÿÿÿÿÿÿÿÿs–þÿ?þÿ?þÿ?þÿAÿSAûõDþÿDþÿgþÿÿÿÿÿÿÿÿÿAtþÿDþÿDþÿj’þÿÿÿÿÿÿÿÿÿM|þÿDþÿDþÿ7lþÿ­ÂþÿÑÝÿÿÂÒÿÿHyþÿDþÿDþÿDþÿTþÿðôÿÿÿÿÿÿîòÿÿNþÿCþÿCþÿDüÈIûøIþÿIþÿ|¡þÿÿÿÿÿÿÿÿÿ)fþÿIþÿIþÿ°ÿÿÿÿÿÿÿÿÿÿWþÿ Qþÿ¥¿ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿˆªÿÿHþÿHþÿHþÿxžþÿÿÿÿÿÿÿÿÿ\ŠþÿHþÿHþÿHþÿFÿ!MûçMþÿMþÿošþÿÿÿÿÿÿÿÿÿ6sþÿMþÿMþÿ‰­ÿÿÿÿÿÿÿÿÿÿ#eþÿÁÔÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýþÿÿ8sþÿLþÿLþÿ^þÿýþÿÿÿÿÿÿªÃÿÿLþÿLþÿLþÿMÿcRýÓRþÿRþÿ\þÿÿÿÿÿÿÿÿÿYŽþÿQþÿQþÿh˜þÿÿÿÿÿÿÿÿÿËÜÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþÿÿþþÿÿÿÿÿÿœ»ÿÿQþÿQþÿQþÿÏÞÿÿÿÿÿÿÛæÿÿQþÿQþÿQþÿOý§Vþ®VþÿVþÿ"mþÿÿÿÿÿÿÿÿÿž¿ÿÿVþÿVþÿcþÿöùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ³ÿÿãìÿÿÿÿÿÿÂÖÿÿUþÿUþÿUþÿ­ÈÿÿÿÿÿÿöùÿÿUþÿUþÿUþÿSýÏ\ÿl[þÿ[þÿZþÿÜèÿÿÿÿÿÿó÷ÿÿjþÿZþÿZþÿz©þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ’¹ÿÿ[þÿçïÿÿÿÿÿÿ»ÓÿÿZþÿZþÿZþÿŸÁÿÿÿÿÿÿþþÿÿ]þÿYþÿYþÿWúàaÿ*_þÿ_þÿ_þÿr§þÿÿÿÿÿÿÿÿÿžÂÿÿ_þÿ_þÿ_þÿ€¯þÿýþÿÿÿÿÿÿÿÿÿÿßëÿÿG‹þÿ^þÿ*yþÿÿÿÿÿÿÿÿÿ—½ÿÿ^þÿ^þÿ^þÿ²Îÿÿÿÿÿÿðöÿÿ^þÿ^þÿ^þÿ[ûòÿaýÔcþÿcþÿhþÿáíÿÿÿÿÿÿÿÿÿÿn¦þÿcþÿcþÿcþÿeþÿ({þÿlþÿcþÿcþÿdþÿ±ÏÿÿÿÿÿÿÿÿÿÿA‹þÿcþÿcþÿcþÿÛéÿÿÿÿÿÿÖæÿÿbþÿbþÿbþÿ_ûóiÿ_hþÿhþÿhþÿH“þÿüýÿÿÿÿÿÿÿÿÿÿ•Àÿÿqþÿhþÿgþÿgþÿgþÿgþÿ mþÿŸÆÿÿÿÿÿÿÿÿÿÿÌáÿÿhþÿgþÿgþÿ zþÿÿÿÿÿÿÿÿÿšÃÿÿgþÿgþÿgþÿgüÜfÿkúálþÿlþÿlþÿj©þÿþþÿÿÿÿÿÿÿÿÿÿíõÿÿ“ÁÿÿQ›þÿ8ŒþÿG•þÿ€¶þÿâîÿÿÿÿÿÿÿÿÿÿîõÿÿ#€þÿlþÿlþÿkþÿ‡¹ÿÿÿÿÿÿÿÿÿÿVþÿkþÿkþÿkþÿiþ³pÿ]qþÿqþÿqþÿqþÿNœþÿð÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿàîÿÿ7þÿpþÿpþÿpþÿ~þÿñ÷ÿÿÿÿÿÿåðÿÿtþÿpþÿpþÿpþÿoÿwtþ­uþÿuþÿuþÿuþÿ€þÿŽÂÿÿñ÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿñ÷ÿÿ“Åÿÿ~þÿuþÿtþÿ yþÿÇàÿÿÉáÿÿÿÿÿÿÿÿÿÿs³þÿtþÿtþÿtþÿtûþvÿ'yÿ{ûçyþÿyþÿyþÿyþÿyþÿ|þÿ@›þÿl²þÿ€¼þÿq´þÿJ þÿ þÿyþÿyþÿyþÿyþÿŽÃþÿÿÿÿÿêôÿÿÿÿÿÿÌäÿÿ|þÿyþÿyþÿyþÿwþ¼}ÿ5~ûô~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ~þÿ}þÿ}þÿ}þÿ}þÿ"ŽþÿäñÿÿÿÿÿÿÿÿÿÿèóÿÿP¥þÿ}þÿ}þÿ}þÿ}þÿ{ÿ<ƒÿD‚üó‚ÿÿ‚ÿÿ‚ÿÿ‚ÿÿ‚ÿÿ‚ÿÿ‚ÿÿ‚ÿÿ‚ÿÿ‚ÿÿ‚ÿÿ‚ÿÿ‚ÿÿŸÐÿÿÿÿÿÿÿÿÿÿýþÿÿÑéÿÿsºÿÿ‚ÿÿ‚ÿÿÿÿý–‰ÿ6…üå‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ‡ÿÿ†ÿÿ†ÿÿ†ÿÿ†ÿÿ†ÿÿ†ÿÿŠÿÿœÐÿÿÓêÿÿ¼ßÿÿi¸ÿÿˆÿÿ†ÿÿ†ÿÿ†ÿÿ‡üÇŽÿ ÿ‹þ»‹ÿÿ‹ÿÿ‹ÿÿ‹ÿÿ‹ÿÿ‹ÿÿ‹ÿÿ‹ÿÿ%œÿÿ‘ÍÿÿÊæÿÿ3¢ÿÿŽÿÿ‹ÿÿ‹ÿÿ‹ÿÿŠÿÿŠÿÿŠüÇŽÿÿÿ‘ÿaŽüÞÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ‹ÌÿÿÿÿÿÿÿÿÿÿÿÿŒüþý˜Žÿ €ÿ”ÿ_’ýÔ”ÿÿ”ÿÿ”ÿÿ”ÿÿ”ÿÿ”ÿÿ$£ÿÿ”ÿÿ“ÿÿ“ÿÿ“ÿÿ“þ½“ÿ;•ÿ$—ÿl˜þ°™ýÑ•üæ˜üû˜üé™ýÑ–þ²˜ÿwšÿ&(0 ÿù\ýš&2üÅùùýîÜÞûì$1üÉý¢ÿeÿ1ÿýiýÐÿÿ9Eÿÿ²¸ÿÿÿÿÿÿ¸¿ÿÿ ÿÿÿÿÿÿüðý ûBÿýÿÿÿÿl{ÿÿìïÿÿÿÿÿÿÚÞÿÿ;Oýÿýÿýÿþÿÿÿÿÿüîûÿÿ "ýŸÿÿ ÿÿƒ“þÿÿÿÿÿÿÿÿÿ¡®þÿ)Cýÿýÿýÿýÿýÿýÿýÿ!ÿÿ"ÿÿ þ¾ø&&ýk'üý ÿÿg~ýÿüüÿÿñóÿÿgþÿ#ýÿýÿ#ýÿ-MýÿTnýÿ[týÿGcýÿ<ýÿýÿ!ÿÿ'ÿÿ'ýÐ&ÿ(1ÿ+ûÙ'ÿÿ&Nþÿèìÿÿÿÿÿÿeþÿþÿ!þÿ5Xþÿ­»þÿéíÿÿÿÿÿÿÿÿÿÿþþÿÿÙàÿÿŽ¡þÿEþÿ$ÿÿ.ÿÿ*üÄÿ3ÿd4ÿÿ1ÿÿˆ þÿÿÿÿÿ£µÿÿ1þÿ&þÿMpþÿçìÿÿÿÿÿÿïóÿÿÇÒÿÿÀÌÿÿÒÜÿÿÿÿÿÿÿÿÿÿÓÜÿÿ@eþÿ*ÿÿ5ÿÿ1ýŒÿ8ý¨7ÿÿFþÿÝåÿÿøúÿÿ;gþÿ&þÿ(Xþÿâêÿÿÿÿÿÿ¤¹ÿÿ4\þÿ2þÿ)þÿ @þÿMsþÿ»Ëþÿÿÿÿÿáèÿÿ1^þÿ1ÿÿ8ýó8ÿD>ûÕ;ÿÿ8iþÿÿÿÿÿÈÖÿÿKþÿ2þÿŒ¨þÿÿÿÿÿ¯Ãÿÿ;þÿ,þÿCþÿ Gþÿ9þÿ,þÿFþÿ¬Àÿÿÿÿÿÿ·ÉÿÿEþÿ=ÿÿ>ú¨UÕBúê@ÿÿ[‡þÿÿÿÿÿ¢»ÿÿ>þÿOþÿÅÕÿÿþþÿÿ3jþÿ@þÿ^‰þÿ»ÍþÿÓßÿÿ…¦þÿSþÿ7þÿWþÿÙãÿÿÿÿÿÿOþÿ=ÿÿDüòCú5KùæFÿÿbþÿÿÿÿÿ›¸ÿÿ@þÿ]þÿ×âÿÿõ÷ÿÿ+iþÿš¸ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¢¾ÿÿJþÿ@þÿo™þÿÿÿÿÿžºÿÿKÿÿLÿÿIýpQýÔNÿÿP‡þÿÿÿÿÿ±ÊÿÿPþÿ WþÿÀÓþÿüýÿÿÁÕÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþÿÿó÷ÿÿ?|ÿÿ?þÿ3sþÿùûÿÿ×äÿÿ YþÿOÿÿPþ­Vþ±Uÿÿ#nþÿøúÿÿäíÿÿ"nþÿFþÿv¦þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¦Äÿÿ¾Ôÿÿÿÿÿÿc—ÿÿDþÿ"mþÿâìÿÿôøÿÿbþÿTÿÿQýÑ]ýv_ÿÿ_ÿÿ¶Ñþÿÿÿÿÿ~­ÿÿQþÿdþÿ©Éþÿÿÿÿÿÿÿÿÿûüÿÿ”»þÿeþÿµÐÿÿÿÿÿÿU’ÿÿLþÿ"rþÿàëÿÿôøÿÿhþÿZÿÿYúâaû:büö^ÿÿGþÿÿÿÿÿôøÿÿO”þÿUþÿdþÿFŽþÿR•þÿ1þÿVþÿBŠþÿøûÿÿåïÿÿ!vþÿUþÿ0€þÿúüÿÿÛéÿÿ jþÿaÿÿ_úèqÿ fü¬mÿÿgþÿ½þÿÿÿÿÿñ÷ÿÿw®ÿÿvþÿbþÿ`þÿhþÿQ—þÿßìÿÿÿÿÿÿ‚µÿÿaþÿaþÿb¢þÿÿÿÿÿ¦ÊÿÿjþÿhÿÿgýÔnûHoýômÿÿtþÿ’Âþÿÿÿÿÿÿÿÿÿàîÿÿ«Ïÿÿ¡ÉÿÿÆßÿÿÿÿÿÿÿÿÿÿ¥Ìþÿ rþÿdþÿrþÿÇßÿÿÿÿÿÿ]£þÿhþÿqÿÿmý©ªÿrý“zÿÿqÿÿtþÿX¤þÿÇàÿÿüþÿÿÿÿÿÿÿÿÿÿÿÿÿÿàîÿÿt´ÿÿ xþÿjþÿQžþÿ±ÓÿÿÿÿÿÿÏåÿÿþÿnÿÿyÿÿtýgózüÈ‚ÿÿwÿÿuþÿ ~þÿ3•þÿ^¬þÿe¯þÿFŸþÿ…þÿvþÿqþÿ‰þÿÙëþÿÿÿÿÿóùÿÿV§ÿÿrþÿÿÿwüÞxÿ ‚ù+ûÕˆÿÿ€ÿÿ}þÿ|þÿ{þÿ{þÿ|þÿ|þÿ|þÿ|ÿÿ„ÂÿÿÿÿÿÿÿÿÿÿÍæÿÿ'’þÿ}ÿÿ„ÿÿ~ýs…ÿ,‡üÄÿÿŠÿÿ†ÿÿ†ÿÿ…ÿÿ…ÿÿ…ÿÿ ‰ÿÿ“ÿÿ§ÖÿÿÑéÿÿ‘Ëÿÿ6ŸÿÿŽÿÿŒÿÿ„ý¨™ÿ ÿŠý™ýô•ÿÿŽÿÿŒÿÿ‹ÿÿŒÿÿ>¨ÿÿžÓÿÿ4£ÿÿ ÿÿ‹ÿÿŒÿÿŽÿÿŠý¦ŒÿüL’ý¨’üøšÿÿ—ÿÿ–ÿÿ”ÿÿ;°ÿÿ™ÿÿ“ÿÿ—ÿÿ”ýÙŽýsŽÿ ™ÿ”ÿ9™ÿq–þ²—ýÓ–üç•üä—ýΕý©™ÿf•ÿ$(  ÿÿÿ* ýmîïý“cmýƒüU#ÿÿÿÿ1ÿ üª üû‘šþÿþþþþ4Eüþüÿüîý• ÿÿ1ÿúá6ýÿßãýýô÷ýüG\üûûûûý ûþüÿ ûí'ûHUÿ'þ¶+ýÿÝâýøÆÒýþ#ýÿ!üþl„üþ§³ýþœªýýKiüú!üþ$üý0üPUÿAÿC$ýÿvýýöùýþ 3üþ DþÿåëþÿúûÿÿÁÎþÿÏÙýþÿÿÿÿÅÐýü;þÿ-üñ>ÿ%>ýˆ4ýÿ×àýü”ªýþ$ýÿÏÚþÿÉ×þÿ4ýÿ"ýÿ"ýÿ RýþáêþÿÄÒýú6ýÿ;ý¨Aý¨Jþÿ÷ùýüRýþTþÿÿÿÿÿ0aþÿIxþÿ¼Îþÿœ¸þÿ Býÿ UýþþþþþW‚þÿ7üöUÿ-Mý RþÿôøýüXˆýþ_þÿöøþÿ´Ëþÿÿÿÿÿûüþÿÿÿÿÿœ»þÿ5ýÿ¾Ïýþ°ÉýüAýÿ Tÿt\ÿtOýÿÈÚýü­ÈýþCýÿ»Òþÿÿÿÿÿÿÿÿÿ¶Ïþÿ¡ÂþÿÐàþÿBýÿ—·ýþÏßýüNýÿYý lÿ-XüöNþÿþþþþKŒýþWýÿWšþÿGþÿ\ýÿÔãþÿ¢ÆþÿIýÿ­Êýþ¿ÖýüVýÿdý¨mý¨dýÿ‰ºýúÿÿÿÿ¡Æýþ@ŽþÿN–þÿÔåþÿíõþÿuþÿdýÿïöýþy°ýü_ýÿoýˆuÿ%uýñmýÿQ¡ýüÕéþÿúýýþùýþÿ´Øþÿþÿ{þÿºÙýþêóýþ}üýqýÿvÿCUÿ|ÿP€ýývýþvýú ‚ýýýþtýþoýþ¬Ôþÿþþþþ¼ýøtþÿ€þ¶Uÿ‡ÿHˆþí‰ÿÿ…þþ…þý ŒþûN©þû–ÎýüZ²ýý‹ÿÿ…þá„ÿªÿŠÿý”ýî‘þÿýþ:ªýþ þÿ†þúþª“ÿÿÿ€ÿÿÿ—ÿ–ÿU—ÿ€ÿˆ™ÿl¤ÿ*ÿÿÿregions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_logo.svg0000644000076600000240000001103213336766207034607 0ustar deilstaff00000000000000 ././@LongLink0000000000000000000000000000014700000000000011217 Lustar 00000000000000regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_logo_32.pngregions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_logo_32.p0000644000076600000240000000353413336766207034563 0ustar deilstaff00000000000000‰PNG  IHDR szzôsBIT|dˆ pHYsÓÇòŽtEXtSoftwarewww.inkscape.org›î<ÙIDATX…Å—PT×Ç?÷ñc‘P° ˆ „FƒUBìȘ&Ådi”I# ±ÒÄJhC2æÇŒ5ÑÔtw:íÛª5ÑÒSÒÆª©é„Ú¡%¨ZÉF2Vk­JFŒ`ÁŠ(JdÙ÷öÝþqaß., É?½3gæ½sÏïýžûΞº®óÿ\Ñ_ÄÉ•ìÎ#šÅHŠl ø2pèZ€Ý8ØãéÔ¯KL”Wš;†AC°È‹h4¥z>ÕÀ$?ñôé—#¹hJ~‹»œ›´`;&y˜#D²ËÂß b0¨Â¤Åu‹»2RìqKàJr'âã7˜<6.´;`Îã2Ò‹@‹†Ž&°Ìa‹$`›+Æâ1ôWB]Ç, w.rÆM¶|»r€Þh?G6B—m"ù‘GêÕïKàƒ…“œ0º#Ñ&¢: WBÅaˆË°mL6¸pÏ€+àΔƒx¥Áti@D1Çä;«áz§ v³ú7zCýrׇóE9ÎÐäš ‹,“é_Gÿ±hbÞˆy•ˆ;¾Ñ Ðñ!,e÷ÙUÄ—¦AÚlˆO†„©ˆ€-^;V€¬…~ï;MçÅðKxUZùK%:Lü剜"¸ë9äžáT½rÝë†3WCúWaá8úè9ô³`p4XW·;KšxBjó«ËwÙÉ¥„Ö÷á“ýÐÚׇ.WêLDå_e5Êw`ÎDîzFíG;ßz9ì¾?@ÈghI^Ž ÄâUˆ¥›Ô³áƒÆMÈl…+çíãÇÄs%bñZˆK„»Ÿ‚Ão@ûÅ`ó!8¹ò—À¬o‚)Ô!ÔÊpu¹4W›;Uü0ˆ0×i'÷Ý@V— ë\Ð}>üÖßôÁž Èu Àôƒˆï¾ ¦übdëÇ‘‰Yáþ>rµ¡z—c0iØI,\1D‹‰ÜX §)‡Ìùׇˆ×üˆ__…Šm cáB3ì߬|f̃¹ÙI.œ²KŸ;ò“NÖ¤AqÐ!~*Üùr8Þg)ã¬BÄß…¬;!*â'#î©DÔôÁürdÓN;Ql’ à|(€Ùá Xôj®€[Ã`aPy÷ã* ÷ר—¦Ô¥h¹bâO½¶Î 9el¢­ïë 0HÆi¦a29HáReÜÝ 5*Ã@ä)}豄 ¢cU5ö»aÙIr mý0›Jú€nARÂPÊør‡j­&5â“+Þðçõ£AL:éµKðAƒÍ\îÿ´ž eà'_Œ໩âlg'ò›Èm/!7|ü¾p7z‘¯T@ß5å—0 KÕÞ¹Àg†öƒ ú@/fHN|ׯ@b bÁÃÈú8X‹lü,yf} ºÚ ®ú•ˆU; )U1·o»bSµ j€~Ú¦‚aS2!&A”8¼/‡‚û ¿Ž7ªhu¯Ž.@ùó0¿D=¿_oo nIøý/© Ió”è70è¦FÞ§¬&%ÀýÁ¶,Ô*}t â—ƒ{Ë#ÿ$'Ï@ütbÅËʾç?ÈuO„Ú j&Á¡DèºÎK î-T㎉E4| )épá,ò;·Ûí³ôˆµ¿…¨!ÊÎ7ÿ¼Èö3ˆiÙ0ý6X°“Ô¾¹ò8önðôB°ÚSjOEÑšÅNi 0ýÈÚ-ˆg<0c&”T@Ãe]· ùßKˆ» .²ó ;©Þzäæç¡³-Tû³™R[åt:iºÝy±è„·‹,, å4âÑçÝEBÛY8{Z5˜öðîFô÷A¬¦¤ƒÐK]àä?‘úÓð»upíjèLñ©,ñ<«÷…" ^?aReÁ ÀAO/¬YŽØü–±áHKCî}K7ÿÙ¼V='N†´ èhß@$.:4Á}žr½säFp"jÊw^ùÆqo?%Š…føä$¢äâþ2HÍ€÷€°O6àƒžËà75E)iנس\o™FÌ„ë*õj¬þ”î{YU†¬¢üI´¿…ܹ㠦!bò¦¦Qà©Ð[Ç¢&âX¾¶Æ])àWHTÿ]º í…ŸAÖ­Ê`Їu×W ëâXq;¤dÍúgõÚ± "20¼Ö¯Ð·k·að:µobÝ3¹u‹2pÄ!}rô¸nÒ,TjÝäN$9Là¿¡k“{rÀâAMP*a¦Öri.©išÜ[ï—ËÊÎ h“Ш™ì÷¼¨7O$éç0 Ë•Lg§$3ó3Çãÿ¼ G®ÿ.Á½8<ßÇIEND®B`‚././@LongLink0000000000000000000000000000015100000000000011212 Lustar 00000000000000regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/static/bootstrap-astropy.cssregions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/static/bootstrap-astropy0000644000076600000240000002744313336766207035021 0ustar deilstaff00000000000000/*! * Bootstrap v1.4.0 * * Copyright 2011 Twitter, Inc * Licensed under the Apache License v2.0 * http://www.apache.org/licenses/LICENSE-2.0 * * Heavily modified by Kyle Barbary for the AstroPy Project for use with Sphinx. */ @import url("basic.css"); body { background-color: #ffffff; margin: 0; font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; font-size: 13px; font-weight: normal; line-height: 18px; color: #404040; } /* Hyperlinks ----------------------------------------------------------------*/ a { color: #0069d6; text-decoration: none; line-height: inherit; font-weight: inherit; } a:hover { color: #00438a; text-decoration: underline; } /* Typography ----------------------------------------------------------------*/ h1,h2,h3,h4,h5,h6 { color: #404040; margin: 0.7em 0 0 0; line-height: 1.5em; } h1 { font-size: 24px; margin: 0; } h2 { font-size: 21px; line-height: 1.2em; margin: 1em 0 0.5em 0; border-bottom: 1px solid #404040; } h3 { font-size: 18px; } h4 { font-size: 16px; } h5 { font-size: 14px; } h6 { font-size: 13px; text-transform: uppercase; } p { font-size: 13px; font-weight: normal; line-height: 18px; margin-top: 0px; margin-bottom: 9px; } ul, ol { margin-left: 0; padding: 0 0 0 25px; } ul ul, ul ol, ol ol, ol ul { margin-bottom: 0; } ul { list-style: disc; } ol { list-style: decimal; } li { line-height: 18px; color: #404040; } ul.unstyled { list-style: none; margin-left: 0; } dl { margin-bottom: 18px; } dl dt, dl dd { line-height: 18px; } dl dd { margin-left: 9px; } hr { margin: 20px 0 19px; border: 0; border-bottom: 1px solid #eee; } strong { font-style: inherit; font-weight: bold; } em { font-style: italic; font-weight: inherit; line-height: inherit; } .muted { color: #bfbfbf; } address { display: block; line-height: 18px; margin-bottom: 18px; } code, pre { padding: 0 3px 2px; font-family: monospace; -webkit-border-radius: 3px; -moz-border-radius: 3px; border-radius: 3px; } tt { font-family: monospace; } code { padding: 1px 3px; } pre { display: block; padding: 8.5px; margin: 0 0 18px; line-height: 18px; border: 1px solid #ddd; border: 1px solid rgba(0, 0, 0, 0.12); -webkit-border-radius: 3px; -moz-border-radius: 3px; border-radius: 3px; white-space: pre; word-wrap: break-word; } img { margin: 9px 0; } /* format inline code with a rounded box */ tt, code { margin: 0 2px; padding: 0 5px; border: 1px solid #ddd; border: 1px solid rgba(0, 0, 0, 0.12); border-radius: 3px; } code.xref, a code { margin: 0; padding: 0 1px 0 1px; background-color: none; border: none; } /* all code has same box background color, even in headers */ h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt, h1 code, h2 code, h3 code, h4 code, h5 code, h6 code, pre, code, tt { background-color: #f8f8f8; } /* override box for links & other sphinx-specifc stuff */ tt.xref, a tt, tt.descname, tt.descclassname { padding: 0 1px 0 1px; border: none; } /* override box for related bar at the top of the page */ .related tt { border: none; padding: 0 1px 0 1px; background-color: transparent; font-weight: bold; } th { background-color: #dddddd; } .viewcode-back { font-family: sans-serif; } div.viewcode-block:target { background-color: #f4debf; border-top: 1px solid #ac9; border-bottom: 1px solid #ac9; } table.docutils { border-spacing: 5px; border-collapse: separate; } /* Topbar --------------------------------------------------------------------*/ div.topbar { height: 40px; position: absolute; top: 0; left: 0; right: 0; z-index: 10000; padding: 0px 10px; background-color: #222; background-color: #222222; background-repeat: repeat-x; background-image: -khtml-gradient(linear, left top, left bottom, from(#333333), to(#222222)); background-image: -moz-linear-gradient(top, #333333, #222222); background-image: -ms-linear-gradient(top, #333333, #222222); background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #333333), color-stop(100%, #222222)); background-image: -webkit-linear-gradient(top, #333333, #222222); background-image: -o-linear-gradient(top, #333333, #222222); background-image: linear-gradient(top, #333333, #222222); filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#333333', endColorstr='#222222', GradientType=0); overflow: auto; } div.topbar a.brand { font-family: 'Source Sans Pro', sans-serif; font-size: 26px; color: #ffffff; font-weight: 600; text-decoration: none; float: left; display: block; height: 32px; padding: 8px 12px 0px 45px; margin-left: -10px; background: transparent url("astropy_logo_32.png") no-repeat 10px 4px; background-image: url("astropy_logo.svg"), none; background-size: 32px 32px; } #logotext1 { } #logotext2 { font-weight:200; color: #ff5000; } #logotext3 { font-weight:200; } div.topbar .brand:hover, div.topbar ul li a.homelink:hover { background-color: #333; background-color: rgba(255, 255, 255, 0.05); } div.topbar ul { font-size: 110%; list-style: none; margin: 0; padding: 0 0 0 10px; float: right; color: #bfbfbf; text-align: center; text-decoration: none; height: 100%; } div.topbar ul li { float: left; display: inline; height: 30px; margin: 5px; padding: 0px; } div.topbar ul li a { color: #bfbfbf; text-decoration: none; padding: 5px; display: block; height: auto; text-align: center; vertical-align: middle; border-radius: 4px; } div.topbar ul li a:hover { color: #ffffff; text-decoration: none; } div.topbar ul li a.homelink { width: 112px; display: block; height: 20px; padding: 5px 0px; background: transparent url("astropy_linkout_20.png") no-repeat 10px 5px; background-image: url("astropy_linkout.svg"), none; background-size: 91px 20px; } div.topbar form { text-align: left; margin: 0 0 0 5px; position: relative; filter: alpha(opacity=100); -khtml-opacity: 1; -moz-opacity: 1; opacity: 1; } div.topbar input { background-color: #444; background-color: rgba(255, 255, 255, 0.3); font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; font-size: normal; font-weight: 13px; line-height: 1; padding: 4px 9px; color: #ffffff; color: rgba(255, 255, 255, 0.75); border: 1px solid #111; -webkit-border-radius: 4px; -moz-border-radius: 4px; border-radius: 4px; -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1), 0 1px 0px rgba(255, 255, 255, 0.25); -moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1), 0 1px 0px rgba(255, 255, 255, 0.25); box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1), 0 1px 0px rgba(255, 255, 255, 0.25); -webkit-transition: none; -moz-transition: none; -ms-transition: none; -o-transition: none; transition: none; } div.topbar input:-moz-placeholder { color: #e6e6e6; } div.topbar input::-webkit-input-placeholder { color: #e6e6e6; } div.topbar input:hover { background-color: #bfbfbf; background-color: rgba(255, 255, 255, 0.5); color: #ffffff; } div.topbar input:focus, div.topbar input.focused { outline: 0; background-color: #ffffff; color: #404040; text-shadow: 0 1px 0 #ffffff; border: 0; padding: 5px 10px; -webkit-box-shadow: 0 0 3px rgba(0, 0, 0, 0.15); -moz-box-shadow: 0 0 3px rgba(0, 0, 0, 0.15); box-shadow: 0 0 3px rgba(0, 0, 0, 0.15); } /* Relation bar (breadcrumbs, prev, next) ------------------------------------*/ div.related { height: 21px; width: auto; margin: 0 10px; position: absolute; top: 42px; clear: both; left: 0; right: 0; z-index: 10000; font-size: 100%; vertical-align: middle; background-color: #fff; border-bottom: 1px solid #bbb; } div.related ul { padding: 0; margin: 0; } /* Footer --------------------------------------------------------------------*/ footer { display: block; margin: 10px 10px 0px; padding: 10px 0 0 0; border-top: 1px solid #bbb; } .pull-right { float: right; width: 30em; text-align: right; } /* Sphinx sidebar ------------------------------------------------------------*/ div.sphinxsidebar { font-size: inherit; border-radius: 3px; background-color: #eee; border: 1px solid #bbb; word-wrap: break-word; /* overflow-wrap is the canonical name for word-wrap in the CSS3 text draft. We include it here mainly for future-proofing. */ overflow-wrap: break-word; } div.sphinxsidebarwrapper { padding: 0px 0px 0px 5px; } div.sphinxsidebar h3 { font-family: 'Trebuchet MS', sans-serif; font-size: 1.4em; font-weight: normal; margin: 5px 0px 0px 5px; padding: 0; line-height: 1.6em; } div.sphinxsidebar h4 { font-family: 'Trebuchet MS', sans-serif; font-size: 1.3em; font-weight: normal; margin: 5px 0 0 0; padding: 0; } div.sphinxsidebar p { } div.sphinxsidebar p.topless { margin: 5px 10px 10px 10px; } div.sphinxsidebar ul { margin: 0px 0px 0px 5px; padding: 0; } div.sphinxsidebar ul ul { margin-left: 15px; list-style-type: disc; } /* If showing the global TOC (toctree), color the current page differently */ div.sphinxsidebar a.current { color: #404040; } div.sphinxsidebar a.current:hover { color: #404040; } /* document, documentwrapper, body, bodywrapper ----------------------------- */ div.document { margin-top: 72px; margin-left: 10px; margin-right: 10px; } div.documentwrapper { float: left; width: 100%; } div.body { background-color: #ffffff; padding: 0 0 0px 20px; } div.bodywrapper { margin: 0 0 0 230px; max-width: 55em; } /* Header links ------------------------------------------------------------- */ a.headerlink { font-size: 0.8em; padding: 0 4px 0 4px; text-decoration: none; } a.headerlink:hover { background-color: #0069d6; color: white; text-docoration: none; } /* Admonitions and warnings ------------------------------------------------- */ /* Shared by admonitions and warnings */ div.admonition, div.warning { padding: 0px; border-radius: 3px; -moz-border-radius: 3px; -webkit-border-radius: 3px; } div.admonition p, div.warning p { margin: 0.5em 1em 0.5em 1em; padding: 0; } div.admonition pre, div.warning pre { margin: 0.4em 1em 0.4em 1em; } div.admonition p.admonition-title, div.warning p.admonition-title { margin: 0; padding: 0.1em 0 0.1em 0.5em; color: white; font-weight: bold; font-size: 1.1em; } div.admonition ul, div.admonition ol, div.warning ul, div.warning ol { margin: 0.1em 0.5em 0.5em 3em; padding: 0; } /* Admonitions only */ div.admonition { border: 1px solid #609060; background-color: #e9ffe9; } div.admonition p.admonition-title { background-color: #70A070; } /* Warnings only */ div.warning { border: 1px solid #900000; background-color: #ffe9e9; } div.warning p.admonition-title { background-color: #b04040; } /* Figures ------------------------------------------------------------------ */ .figure.align-center { clear: none; } /* This is a div for containing multiple figures side-by-side, for use with * .. container:: figures */ div.figures { border: 1px solid #CCCCCC; background-color: #F8F8F8; margin: 1em; text-align: center; } div.figures .figure { clear: none; float: none; display: inline-block; border: none; margin-left: 0.5em; margin-right: 0.5em; } .field-list th { white-space: nowrap; } table.field-list { border-spacing: 0px; margin-left: 1px; border-left: 5px solid rgb(238, 238, 238) !important; } table.field-list th.field-name { display: inline-block; padding: 1px 8px 1px 5px; white-space: nowrap; background-color: rgb(238, 238, 238); border-radius: 0 3px 3px 0; -webkit-border-radius: 0 3px 3px 0; } regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/static/copybutton.js0000644000076600000240000000532113336766207034115 0ustar deilstaff00000000000000$(document).ready(function() { /* Add a [>>>] button on the top-right corner of code samples to hide * the >>> and ... prompts and the output and thus make the code * copyable. */ var div = $('.highlight-python .highlight,' + '.highlight-python3 .highlight,' + '.highlight-default .highlight') var pre = div.find('pre'); // get the styles from the current theme pre.parent().parent().css('position', 'relative'); var hide_text = 'Hide the prompts and output'; var show_text = 'Show the prompts and output'; var border_width = pre.css('border-top-width'); var border_style = pre.css('border-top-style'); var border_color = pre.css('border-top-color'); var button_styles = { 'cursor':'pointer', 'position': 'absolute', 'top': '0', 'right': '0', 'border-color': border_color, 'border-style': border_style, 'border-width': border_width, 'color': border_color, 'text-size': '75%', 'font-family': 'monospace', 'padding-left': '0.2em', 'padding-right': '0.2em', 'border-radius': '0 3px 0 0' } // create and add the button to all the code blocks that contain >>> div.each(function(index) { var jthis = $(this); if (jthis.find('.gp').length > 0) { var button = $('>>>'); button.css(button_styles) button.attr('title', hide_text); button.data('hidden', 'false'); jthis.prepend(button); } // tracebacks (.gt) contain bare text elements that need to be // wrapped in a span to work with .nextUntil() (see later) jthis.find('pre:has(.gt)').contents().filter(function() { return ((this.nodeType == 3) && (this.data.trim().length > 0)); }).wrap(''); }); // define the behavior of the button when it's clicked $('.copybutton').click(function(e){ e.preventDefault(); var button = $(this); if (button.data('hidden') === 'false') { // hide the code output button.parent().find('.go, .gp, .gt').hide(); button.next('pre').find('.gt').nextUntil('.gp, .go').css('visibility', 'hidden'); button.css('text-decoration', 'line-through'); button.attr('title', show_text); button.data('hidden', 'true'); } else { // show the code output button.parent().find('.go, .gp, .gt').show(); button.next('pre').find('.gt').nextUntil('.gp, .go').css('visibility', 'visible'); button.css('text-decoration', 'none'); button.attr('title', hide_text); button.data('hidden', 'false'); } }); }); regions-0.4/astropy_helpers/astropy_helpers/sphinx/themes/bootstrap-astropy/static/sidebar.js0000644000076600000240000001155313336766207033324 0ustar deilstaff00000000000000/* * sidebar.js * ~~~~~~~~~~ * * This script makes the Sphinx sidebar collapsible. * * .sphinxsidebar contains .sphinxsidebarwrapper. This script adds * in .sphixsidebar, after .sphinxsidebarwrapper, the #sidebarbutton * used to collapse and expand the sidebar. * * When the sidebar is collapsed the .sphinxsidebarwrapper is hidden * and the width of the sidebar and the margin-left of the document * are decreased. When the sidebar is expanded the opposite happens. * This script saves a per-browser/per-session cookie used to * remember the position of the sidebar among the pages. * Once the browser is closed the cookie is deleted and the position * reset to the default (expanded). * * :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS. * :license: BSD, see LICENSE for details. * */ $(function() { // global elements used by the functions. // the 'sidebarbutton' element is defined as global after its // creation, in the add_sidebar_button function var bodywrapper = $('.bodywrapper'); var sidebar = $('.sphinxsidebar'); var sidebarwrapper = $('.sphinxsidebarwrapper'); // for some reason, the document has no sidebar; do not run into errors if (!sidebar.length) return; // original margin-left of the bodywrapper and width of the sidebar // with the sidebar expanded var bw_margin_expanded = bodywrapper.css('margin-left'); var ssb_width_expanded = sidebar.width(); // margin-left of the bodywrapper and width of the sidebar // with the sidebar collapsed var bw_margin_collapsed = 12; var ssb_width_collapsed = 12; // custom colors var dark_color = '#404040'; var light_color = '#505050'; function sidebar_is_collapsed() { return sidebarwrapper.is(':not(:visible)'); } function toggle_sidebar() { if (sidebar_is_collapsed()) expand_sidebar(); else collapse_sidebar(); } function collapse_sidebar() { sidebarwrapper.hide(); sidebar.css('width', ssb_width_collapsed); bodywrapper.css('margin-left', bw_margin_collapsed); sidebarbutton.css({ 'margin-left': '-1px', 'height': bodywrapper.height(), 'border-radius': '3px' }); sidebarbutton.find('span').text('»'); sidebarbutton.attr('title', _('Expand sidebar')); document.cookie = 'sidebar=collapsed'; } function expand_sidebar() { bodywrapper.css('margin-left', bw_margin_expanded); sidebar.css('width', ssb_width_expanded); sidebarwrapper.show(); sidebarbutton.css({ 'margin-left': ssb_width_expanded - 12, 'height': bodywrapper.height(), 'border-radius': '0px 3px 3px 0px' }); sidebarbutton.find('span').text('«'); sidebarbutton.attr('title', _('Collapse sidebar')); document.cookie = 'sidebar=expanded'; } function add_sidebar_button() { sidebarwrapper.css({ 'float': 'left', 'margin-right': '0', 'width': ssb_width_expanded - 18 }); // create the button sidebar.append('
«
'); var sidebarbutton = $('#sidebarbutton'); // find the height of the viewport to center the '<<' in the page var viewport_height; if (window.innerHeight) viewport_height = window.innerHeight; else viewport_height = $(window).height(); var sidebar_offset = sidebar.offset().top; var sidebar_height = Math.max(bodywrapper.height(), sidebar.height()); sidebarbutton.find('span').css({ 'font-family': '"Lucida Grande",Arial,sans-serif', 'display': 'block', 'top': Math.min(viewport_height/2, sidebar_height/2 + sidebar_offset) - 10, 'width': 12, 'position': 'fixed', 'text-align': 'center' }); sidebarbutton.click(toggle_sidebar); sidebarbutton.attr('title', _('Collapse sidebar')); sidebarbutton.css({ 'color': '#FFFFFF', 'background-color': light_color, 'border': '1px solid ' + light_color, 'border-radius': '0px 3px 3px 0px', 'font-size': '1.2em', 'cursor': 'pointer', 'height': sidebar_height, 'padding-top': '1px', 'margin': '-1px', 'margin-left': ssb_width_expanded - 12 }); sidebarbutton.hover( function () { $(this).css('background-color', dark_color); }, function () { $(this).css('background-color', light_color); } ); } function set_position_from_cookie() { if (!document.cookie) return; var items = document.cookie.split(';'); for(var k=0; k= 7: eggs = glob.glob(os.path.join(path, '.eggs', '*.egg')) else: eggs = glob.glob('*.egg') return eggs regions-0.4/astropy_helpers/astropy_helpers/tests/test_git_helpers.py0000644000076600000240000002013213336766207026625 0ustar deilstaff00000000000000import glob import imp import os import pkgutil import re import sys import tarfile import pytest from warnings import catch_warnings from . import reset_setup_helpers, reset_distutils_log # noqa from . import run_cmd, run_setup, cleanup_import from astropy_helpers.git_helpers import get_git_devstr PY3 = sys.version_info[0] == 3 if PY3: _text_type = str else: _text_type = unicode # noqa _DEV_VERSION_RE = re.compile(r'\d+\.\d+(?:\.\d+)?\.dev(\d+)') ASTROPY_HELPERS_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')) TEST_VERSION_SETUP_PY = """\ #!/usr/bin/env python import sys from setuptools import setup NAME = 'apyhtest_eva' VERSION = {version!r} RELEASE = 'dev' not in VERSION sys.path.insert(0, r'{astropy_helpers_path}') from astropy_helpers.git_helpers import get_git_devstr from astropy_helpers.version_helpers import generate_version_py if not RELEASE: VERSION += get_git_devstr(False) generate_version_py(NAME, VERSION, RELEASE, False, uses_git=not RELEASE) setup(name=NAME, version=VERSION, packages=['apyhtest_eva']) """ TEST_VERSION_INIT = """\ try: from .version import version as __version__ from .version import githash as __githash__ except ImportError: __version__ = __githash__ = '' """ @pytest.fixture def version_test_package(tmpdir, request): def make_test_package(version='42.42.dev'): test_package = tmpdir.mkdir('test_package') test_package.join('setup.py').write( TEST_VERSION_SETUP_PY.format(version=version, astropy_helpers_path=ASTROPY_HELPERS_PATH)) test_package.mkdir('apyhtest_eva').join('__init__.py').write(TEST_VERSION_INIT) with test_package.as_cwd(): run_cmd('git', ['init']) run_cmd('git', ['add', '--all']) run_cmd('git', ['commit', '-m', 'test package']) if '' in sys.path: sys.path.remove('') sys.path.insert(0, '') def finalize(): cleanup_import('apyhtest_eva') request.addfinalizer(finalize) return test_package return make_test_package def test_update_git_devstr(version_test_package, capsys): """Tests that the commit number in the package's version string updates after git commits even without re-running setup.py. """ # We have to call version_test_package to actually create the package test_pkg = version_test_package() with test_pkg.as_cwd(): run_setup('setup.py', ['--version']) stdout, stderr = capsys.readouterr() version = stdout.strip() m = _DEV_VERSION_RE.match(version) assert m, ( "Stdout did not match the version string pattern:" "\n\n{0}\n\nStderr:\n\n{1}".format(stdout, stderr)) revcount = int(m.group(1)) import apyhtest_eva assert apyhtest_eva.__version__ == version # Make a silly git commit with open('.test', 'w'): pass run_cmd('git', ['add', '.test']) run_cmd('git', ['commit', '-m', 'test']) import apyhtest_eva.version imp.reload(apyhtest_eva.version) # Previously this checked packagename.__version__, but in order for that to # be updated we also have to re-import _astropy_init which could be tricky. # Checking directly that the packagename.version module was updated is # sufficient: m = _DEV_VERSION_RE.match(apyhtest_eva.version.version) assert m assert int(m.group(1)) == revcount + 1 # This doesn't test astropy_helpers.get_helpers.update_git_devstr directly # since a copy of that function is made in packagename.version (so that it # can work without astropy_helpers installed). In order to get test # coverage on the actual astropy_helpers copy of that function just call it # directly and compare to the value in packagename from astropy_helpers.git_helpers import update_git_devstr newversion = update_git_devstr(version, path=str(test_pkg)) assert newversion == apyhtest_eva.version.version def test_version_update_in_other_repos(version_test_package, tmpdir): """ Regression test for https://github.com/astropy/astropy-helpers/issues/114 and for https://github.com/astropy/astropy-helpers/issues/107 """ test_pkg = version_test_package() with test_pkg.as_cwd(): run_setup('setup.py', ['build']) # Add the path to the test package to sys.path for now sys.path.insert(0, str(test_pkg)) try: import apyhtest_eva m = _DEV_VERSION_RE.match(apyhtest_eva.__version__) assert m correct_revcount = int(m.group(1)) with tmpdir.as_cwd(): testrepo = tmpdir.mkdir('testrepo') testrepo.chdir() # Create an empty git repo run_cmd('git', ['init']) import apyhtest_eva.version imp.reload(apyhtest_eva.version) m = _DEV_VERSION_RE.match(apyhtest_eva.version.version) assert m assert int(m.group(1)) == correct_revcount correct_revcount = int(m.group(1)) # Add several commits--more than the revcount for the apyhtest_eva package for idx in range(correct_revcount + 5): test_filename = '.test' + str(idx) testrepo.ensure(test_filename) run_cmd('git', ['add', test_filename]) run_cmd('git', ['commit', '-m', 'A message']) import apyhtest_eva.version imp.reload(apyhtest_eva.version) m = _DEV_VERSION_RE.match(apyhtest_eva.version.version) assert m assert int(m.group(1)) == correct_revcount correct_revcount = int(m.group(1)) finally: sys.path.remove(str(test_pkg)) @pytest.mark.parametrize('version', ['1.0.dev', '1.0']) def test_installed_git_version(version_test_package, version, tmpdir, capsys): """ Test for https://github.com/astropy/astropy-helpers/issues/87 Ensures that packages installed with astropy_helpers have a correct copy of the git hash of the installed commit. """ # To test this, it should suffice to build a source dist, unpack it # somewhere outside the git repository, and then do a build and import # from the build directory--no need to "install" as such test_pkg = version_test_package(version) with test_pkg.as_cwd(): run_setup('setup.py', ['build']) try: import apyhtest_eva githash = apyhtest_eva.__githash__ assert githash and isinstance(githash, _text_type) # Ensure that it does in fact look like a git hash and not some # other arbitrary string assert re.match(r'[0-9a-f]{40}', githash) finally: cleanup_import('apyhtest_eva') run_setup('setup.py', ['sdist', '--dist-dir=dist', '--formats=gztar']) tgzs = glob.glob(os.path.join('dist', '*.tar.gz')) assert len(tgzs) == 1 tgz = test_pkg.join(tgzs[0]) build_dir = tmpdir.mkdir('build_dir') tf = tarfile.open(str(tgz), mode='r:gz') tf.extractall(str(build_dir)) with build_dir.as_cwd(): pkg_dir = glob.glob('apyhtest_eva-*')[0] os.chdir(pkg_dir) with catch_warnings(record=True) as w: run_setup('setup.py', ['build']) try: import apyhtest_eva loader = pkgutil.get_loader('apyhtest_eva') # Ensure we are importing the 'packagename' that was just unpacked # into the build_dir assert loader.get_filename().startswith(str(build_dir)) assert apyhtest_eva.__githash__ == githash finally: cleanup_import('apyhtest_eva') def test_get_git_devstr(tmpdir): dirpath = str(tmpdir) warn_msg = "No git repository present at" # Verify as much as possible, but avoid dealing with paths on windows if not sys.platform.startswith('win'): warn_msg += " '{}'".format(dirpath) with catch_warnings(record=True) as w: devstr = get_git_devstr(path=dirpath) assert devstr == '0' assert len(w) == 1 assert str(w[0].message).startswith(warn_msg) regions-0.4/astropy_helpers/astropy_helpers/tests/test_openmp_helpers.py0000644000076600000240000000232013336766207027337 0ustar deilstaff00000000000000import os import sys from copy import deepcopy from distutils.core import Extension from ..openmp_helpers import add_openmp_flags_if_available from ..setup_helpers import _module_state, register_commands IS_TRAVIS_LINUX = os.environ.get('TRAVIS_OS_NAME', None) == 'linux' IS_APPVEYOR = os.environ.get('APPVEYOR', None) == 'True' PY3_LT_35 = sys.version_info[0] == 3 and sys.version_info[1] < 5 _state = None def setup_function(function): global state state = deepcopy(_module_state) def teardown_function(function): _module_state.clear() _module_state.update(state) def test_add_openmp_flags_if_available(): register_commands('openmp_testing', '0.0', False) using_openmp = add_openmp_flags_if_available(Extension('test', [])) # Make sure that on Travis (Linux) and AppVeyor OpenMP does get used (for # MacOS X usually it will not work but this will depend on the compiler). # Having this is useful because we'll find out if OpenMP no longer works # for any reason on platforms on which it does work at the time of writing. # OpenMP doesn't work on Python 3.x where x<5 on AppVeyor though. if IS_TRAVIS_LINUX or (IS_APPVEYOR and not PY3_LT_35): assert using_openmp regions-0.4/astropy_helpers/astropy_helpers/tests/test_setup_helpers.py0000644000076600000240000004445413467311012027200 0ustar deilstaff00000000000000import os import sys import stat import shutil import imp import contextlib import pytest from textwrap import dedent from setuptools import Distribution from ..setup_helpers import get_package_info, register_commands from ..commands import build_ext from . import reset_setup_helpers, reset_distutils_log # noqa from . import run_setup, cleanup_import ASTROPY_HELPERS_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')) # Determine whether we're in a PY2 environment without using six USING_PY2 = sys.version_info < (3,0,0) def _extension_test_package(tmpdir, request, extension_type='c', include_numpy=False): """Creates a simple test package with an extension module.""" test_pkg = tmpdir.mkdir('test_pkg') test_pkg.mkdir('apyhtest_eva').ensure('__init__.py') # TODO: It might be later worth making this particular test package into a # reusable fixture for other build_ext tests if extension_type in ('c', 'both'): # A minimal C extension for testing test_pkg.join('apyhtest_eva', 'unit01.c').write(dedent("""\ #include #ifndef PY3K #if PY_MAJOR_VERSION >= 3 #define PY3K 1 #else #define PY3K 0 #endif #endif #if PY3K static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "unit01", NULL, -1, NULL }; PyMODINIT_FUNC PyInit_unit01(void) { return PyModule_Create(&moduledef); } #else PyMODINIT_FUNC initunit01(void) { Py_InitModule3("unit01", NULL, NULL); } #endif """)) if extension_type in ('pyx', 'both'): # A minimal Cython extension for testing test_pkg.join('apyhtest_eva', 'unit02.pyx').write(dedent("""\ print("Hello cruel angel.") """)) if extension_type == 'c': extensions = ['unit01.c'] elif extension_type == 'pyx': extensions = ['unit02.pyx'] elif extension_type == 'both': extensions = ['unit01.c', 'unit02.pyx'] include_dirs = ['numpy'] if include_numpy else [] extensions_list = [ "Extension('apyhtest_eva.{0}', [join('apyhtest_eva', '{1}')], include_dirs={2})".format( os.path.splitext(extension)[0], extension, include_dirs) for extension in extensions] test_pkg.join('apyhtest_eva', 'setup_package.py').write(dedent("""\ from setuptools import Extension from os.path import join def get_extensions(): return [{0}] """.format(', '.join(extensions_list)))) test_pkg.join('setup.py').write(dedent("""\ import sys from os.path import join from setuptools import setup sys.path.insert(0, r'{astropy_helpers_path}') from astropy_helpers.setup_helpers import register_commands from astropy_helpers.setup_helpers import get_package_info from astropy_helpers.version_helpers import generate_version_py if '--no-cython' in sys.argv: from astropy_helpers.commands import build_ext build_ext.should_build_with_cython = lambda *args: False sys.argv.remove('--no-cython') NAME = 'apyhtest_eva' VERSION = '0.1' RELEASE = True cmdclassd = register_commands(NAME, VERSION, RELEASE) generate_version_py(NAME, VERSION, RELEASE, False, False) package_info = get_package_info() setup( name=NAME, version=VERSION, cmdclass=cmdclassd, **package_info ) """.format(astropy_helpers_path=ASTROPY_HELPERS_PATH))) if '' in sys.path: sys.path.remove('') sys.path.insert(0, '') def finalize(): cleanup_import('apyhtest_eva') request.addfinalizer(finalize) return test_pkg @pytest.fixture def extension_test_package(tmpdir, request): return _extension_test_package(tmpdir, request, extension_type='both') @pytest.fixture def c_extension_test_package(tmpdir, request): # Check whether numpy is installed in the test environment # For Python2 compatibility we need to do this hack rather than using # importlib.util.find_spec without the try/except try: has_numpy = bool(imp.find_module('numpy')) except ImportError: has_numpy = False return _extension_test_package(tmpdir, request, extension_type='c', include_numpy=has_numpy) @pytest.fixture def pyx_extension_test_package(tmpdir, request): return _extension_test_package(tmpdir, request, extension_type='pyx') def test_cython_autoextensions(tmpdir): """ Regression test for https://github.com/astropy/astropy-helpers/pull/19 Ensures that Cython extensions in sub-packages are discovered and built only once. """ # Make a simple test package test_pkg = tmpdir.mkdir('test_pkg') test_pkg.mkdir('yoda').mkdir('luke') test_pkg.ensure('yoda', '__init__.py') test_pkg.ensure('yoda', 'luke', '__init__.py') test_pkg.join('yoda', 'luke', 'dagobah.pyx').write( """def testfunc(): pass""") # Required, currently, for get_package_info to work register_commands('yoda', '0.0', False, srcdir=str(test_pkg)) package_info = get_package_info(str(test_pkg)) assert len(package_info['ext_modules']) == 1 assert package_info['ext_modules'][0].name == 'yoda.luke.dagobah' def test_compiler_module(capsys, c_extension_test_package): """ Test ensuring that the compiler module is built and installed for packages that have extension modules. """ test_pkg = c_extension_test_package install_temp = test_pkg.mkdir('install_temp') with test_pkg.as_cwd(): # This is one of the simplest ways to install just a package into a # test directory run_setup('setup.py', ['install', '--single-version-externally-managed', '--install-lib={0}'.format(install_temp), '--record={0}'.format(install_temp.join('record.txt'))]) stdout, stderr = capsys.readouterr() assert "No git repository present at" in stderr with install_temp.as_cwd(): import apyhtest_eva # Make sure we imported the apyhtest_eva package from the correct place dirname = os.path.abspath(os.path.dirname(apyhtest_eva.__file__)) assert dirname == str(install_temp.join('apyhtest_eva')) import apyhtest_eva._compiler import apyhtest_eva.version assert apyhtest_eva.version.compiler == apyhtest_eva._compiler.compiler assert apyhtest_eva.version.compiler != 'unknown' def test_no_cython_buildext(capsys, c_extension_test_package, monkeypatch): """ Regression test for https://github.com/astropy/astropy-helpers/pull/35 This tests the custom build_ext command installed by astropy_helpers when used with a project that has no Cython extensions (but does have one or more normal C extensions). """ test_pkg = c_extension_test_package with test_pkg.as_cwd(): run_setup('setup.py', ['build_ext', '--inplace', '--no-cython']) stdout, stderr = capsys.readouterr() assert "No git repository present at" in stderr sys.path.insert(0, str(test_pkg)) try: import apyhtest_eva.unit01 dirname = os.path.abspath(os.path.dirname(apyhtest_eva.unit01.__file__)) assert dirname == str(test_pkg.join('apyhtest_eva')) finally: sys.path.remove(str(test_pkg)) def test_missing_cython_c_files(capsys, pyx_extension_test_package, monkeypatch): """ Regression test for https://github.com/astropy/astropy-helpers/pull/181 Test failure mode when building a package that has Cython modules, but where Cython is not installed and the generated C files are missing. """ test_pkg = pyx_extension_test_package with test_pkg.as_cwd(): run_setup('setup.py', ['build_ext', '--inplace', '--no-cython']) stdout, stderr = capsys.readouterr() assert "No git repository present at" in stderr msg = ('Could not find C/C++ file ' '{0}.(c/cpp)'.format('apyhtest_eva/unit02'.replace('/', os.sep))) assert msg in stderr @pytest.mark.parametrize('mode', ['cli', 'cli-w', 'deprecated', 'cli-l']) def test_build_docs(capsys, tmpdir, mode): """ Test for build_docs """ test_pkg = tmpdir.mkdir('test_pkg') test_pkg.mkdir('mypackage') test_pkg.join('mypackage').join('__init__.py').write(dedent("""\ def test_function(): pass class A(): pass class B(A): pass """)) test_pkg.mkdir('docs') docs = test_pkg.join('docs') autosummary = docs.mkdir('_templates').mkdir('autosummary') autosummary.join('base.rst').write('{% extends "autosummary_core/base.rst" %}') autosummary.join('class.rst').write('{% extends "autosummary_core/class.rst" %}') autosummary.join('module.rst').write('{% extends "autosummary_core/module.rst" %}') docs_dir = test_pkg.join('docs') docs_dir.join('conf.py').write(dedent("""\ import sys sys.path.insert(0, r'{0}') import warnings with warnings.catch_warnings(): # ignore matplotlib warning warnings.simplefilter("ignore") from astropy_helpers.sphinx.conf import * exclude_patterns.append('_templates') """.format(ASTROPY_HELPERS_PATH))) docs_dir.join('index.rst').write(dedent("""\ .. automodapi:: mypackage :no-inheritance-diagram: """)) test_pkg.join('setup.py').write(dedent("""\ import sys sys.path.insert(0, r'{astropy_helpers_path}') from os.path import join from setuptools import setup, Extension from astropy_helpers.setup_helpers import register_commands, get_package_info NAME = 'mypackage' VERSION = 0.1 RELEASE = True cmdclassd = register_commands(NAME, VERSION, RELEASE) setup( name=NAME, version=VERSION, cmdclass=cmdclassd, **get_package_info() ) """.format(astropy_helpers_path=ASTROPY_HELPERS_PATH))) with test_pkg.as_cwd(): if mode == 'cli': run_setup('setup.py', ['build_docs']) elif mode == 'cli-w': run_setup('setup.py', ['build_docs', '-w']) elif mode == 'cli-l': run_setup('setup.py', ['build_docs', '-l']) elif mode == 'deprecated': run_setup('setup.py', ['build_sphinx']) stdout, stderr = capsys.readouterr() assert 'AstropyDeprecationWarning' in stderr assert os.path.exists(docs_dir.join('_build', 'html', 'index.html').strpath) def test_command_hooks(tmpdir, capsys): """A basic test for pre- and post-command hooks.""" test_pkg = tmpdir.mkdir('test_pkg') test_pkg.mkdir('_welltall_') test_pkg.join('_welltall_', '__init__.py').ensure() # Create a setup_package module with a couple of command hooks in it test_pkg.join('_welltall_', 'setup_package.py').write(dedent("""\ def pre_build_hook(cmd_obj): print('Hello build!') def post_build_hook(cmd_obj): print('Goodbye build!') """)) # A simple setup.py for the test package--running register_commands should # discover and enable the command hooks test_pkg.join('setup.py').write(dedent("""\ import sys from os.path import join from setuptools import setup, Extension sys.path.insert(0, r'{astropy_helpers_path}') from astropy_helpers.setup_helpers import register_commands, get_package_info NAME = '_welltall_' VERSION = 0.1 RELEASE = True cmdclassd = register_commands(NAME, VERSION, RELEASE) setup( name=NAME, version=VERSION, cmdclass=cmdclassd ) """.format(astropy_helpers_path=ASTROPY_HELPERS_PATH))) with test_pkg.as_cwd(): try: run_setup('setup.py', ['build']) finally: cleanup_import('_welltall_') stdout, stderr = capsys.readouterr() want = dedent("""\ running build running pre_hook from _welltall_.setup_package for build command Hello build! running post_hook from _welltall_.setup_package for build command Goodbye build! """).strip() assert want in stdout.replace('\r\n', '\n').replace('\r', '\n') def test_adjust_compiler(monkeypatch, tmpdir): """ Regression test for https://github.com/astropy/astropy-helpers/issues/182 """ from distutils import ccompiler, sysconfig class MockLog(object): def __init__(self): self.messages = [] def warn(self, message): self.messages.append(message) good = tmpdir.join('gcc-good') good.write(dedent("""\ #!{python} import sys print('gcc 4.10') sys.exit(0) """.format(python=sys.executable))) good.chmod(stat.S_IRUSR | stat.S_IEXEC) # A "compiler" that reports itself to be a version of Apple's llvm-gcc # which is broken bad = tmpdir.join('gcc-bad') bad.write(dedent("""\ #!{python} import sys print('i686-apple-darwin-llvm-gcc-4.2') sys.exit(0) """.format(python=sys.executable))) bad.chmod(stat.S_IRUSR | stat.S_IEXEC) # A "compiler" that doesn't even know its identity (this reproduces the bug # in #182) ugly = tmpdir.join('gcc-ugly') ugly.write(dedent("""\ #!{python} import sys sys.exit(1) """.format(python=sys.executable))) ugly.chmod(stat.S_IRUSR | stat.S_IEXEC) # Scripts with shebang lines don't work implicitly in Windows when passed # to subprocess.Popen, so... if 'win' in sys.platform: good = ' '.join((sys.executable, str(good))) bad = ' '.join((sys.executable, str(bad))) ugly = ' '.join((sys.executable, str(ugly))) dist = Distribution({}) cmd_cls = build_ext.generate_build_ext_command('astropy', False) cmd = cmd_cls(dist) adjust_compiler = cmd._adjust_compiler @contextlib.contextmanager def test_setup(): log = MockLog() monkeypatch.setattr(build_ext, 'log', log) yield log monkeypatch.undo() @contextlib.contextmanager def compiler_setter_with_environ(compiler): monkeypatch.setenv('CC', compiler) with test_setup() as log: yield log monkeypatch.undo() @contextlib.contextmanager def compiler_setter_with_sysconfig(compiler): monkeypatch.setattr(ccompiler, 'get_default_compiler', lambda: 'unix') monkeypatch.setattr(sysconfig, 'get_config_var', lambda v: compiler) old_cc = os.environ.get('CC') if old_cc is not None: del os.environ['CC'] with test_setup() as log: yield log monkeypatch.undo() monkeypatch.undo() monkeypatch.undo() if old_cc is not None: os.environ['CC'] = old_cc compiler_setters = (compiler_setter_with_environ, compiler_setter_with_sysconfig) for compiler_setter in compiler_setters: with compiler_setter(str(good)): # Should have no side-effects adjust_compiler() with compiler_setter(str(ugly)): # Should just pass without complaint, since we can't determine # anything about the compiler anyways adjust_compiler() # In the following tests we check the log messages just to ensure that the # failures occur on the correct code paths for these cases with compiler_setter_with_environ(str(bad)) as log: with pytest.raises(SystemExit): adjust_compiler() assert len(log.messages) == 1 assert 'will fail to compile' in log.messages[0] with compiler_setter_with_sysconfig(str(bad)): adjust_compiler() assert 'CC' in os.environ and os.environ['CC'] == 'clang' with compiler_setter_with_environ('bogus') as log: with pytest.raises(SystemExit): # Missing compiler? adjust_compiler() assert len(log.messages) == 1 assert 'cannot be found or executed' in log.messages[0] with compiler_setter_with_sysconfig('bogus') as log: with pytest.raises(SystemExit): # Missing compiler? adjust_compiler() assert len(log.messages) == 1 assert 'The C compiler used to compile Python' in log.messages[0] def test_invalid_package_exclusion(tmpdir, capsys): module_name = 'foobar' setup_header = dedent("""\ import sys from os.path import join from setuptools import setup, Extension sys.path.insert(0, r'{astropy_helpers_path}') from astropy_helpers.setup_helpers import register_commands, \\ get_package_info, add_exclude_packages NAME = {module_name!r} VERSION = 0.1 RELEASE = True """.format(module_name=module_name, astropy_helpers_path=ASTROPY_HELPERS_PATH)) setup_footer = dedent("""\ setup( name=NAME, version=VERSION, cmdclass=cmdclassd, **package_info ) """) # Test error when using add_package_excludes out of order error_commands = dedent("""\ cmdclassd = register_commands(NAME, VERSION, RELEASE) package_info = get_package_info() add_exclude_packages(['tests*']) """) error_pkg = tmpdir.mkdir('error_pkg') error_pkg.join('setup.py').write( setup_header + error_commands + setup_footer) with error_pkg.as_cwd(): run_setup('setup.py', ['build']) stdout, stderr = capsys.readouterr() assert "RuntimeError" in stderr # Test warning when using deprecated exclude parameter warn_commands = dedent("""\ cmdclassd = register_commands(NAME, VERSION, RELEASE) package_info = get_package_info(exclude=['test*']) """) warn_pkg = tmpdir.mkdir('warn_pkg') warn_pkg.join('setup.py').write( setup_header + warn_commands + setup_footer) with warn_pkg.as_cwd(): run_setup('setup.py', ['build']) stdout, stderr = capsys.readouterr() assert 'AstropyDeprecationWarning' in stderr regions-0.4/astropy_helpers/astropy_helpers/tests/test_utils.py0000644000076600000240000000135713336766207025470 0ustar deilstaff00000000000000import os from ..utils import find_data_files def test_find_data_files(tmpdir): data = tmpdir.mkdir('data') sub1 = data.mkdir('sub1') sub2 = data.mkdir('sub2') sub3 = sub1.mkdir('sub3') for directory in (data, sub1, sub2, sub3): filename = directory.join('data.dat').strpath with open(filename, 'w') as f: f.write('test') filenames = find_data_files(data.strpath, '**/*.dat') filenames = sorted(os.path.relpath(x, data.strpath) for x in filenames) assert filenames[0] == os.path.join('data.dat') assert filenames[1] == os.path.join('sub1', 'data.dat') assert filenames[2] == os.path.join('sub1', 'sub3', 'data.dat') assert filenames[3] == os.path.join('sub2', 'data.dat') regions-0.4/astropy_helpers/astropy_helpers/utils.py0000644000076600000240000006476513336766207023303 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, unicode_literals import contextlib import functools import imp import inspect import os import sys import glob import textwrap import types import warnings try: from importlib import machinery as import_machinery # Python 3.2 does not have SourceLoader if not hasattr(import_machinery, 'SourceLoader'): import_machinery = None except ImportError: import_machinery = None # Python 3.3's importlib caches filesystem reads for faster imports in the # general case. But sometimes it's necessary to manually invalidate those # caches so that the import system can pick up new generated files. See # https://github.com/astropy/astropy/issues/820 if sys.version_info[:2] >= (3, 3): from importlib import invalidate_caches else: def invalidate_caches(): return None # Python 2/3 compatibility if sys.version_info[0] < 3: string_types = (str, unicode) # noqa else: string_types = (str,) # Note: The following Warning subclasses are simply copies of the Warnings in # Astropy of the same names. class AstropyWarning(Warning): """ The base warning class from which all Astropy warnings should inherit. Any warning inheriting from this class is handled by the Astropy logger. """ class AstropyDeprecationWarning(AstropyWarning): """ A warning class to indicate a deprecated feature. """ class AstropyPendingDeprecationWarning(PendingDeprecationWarning, AstropyWarning): """ A warning class to indicate a soon-to-be deprecated feature. """ def _get_platlib_dir(cmd): """ Given a build command, return the name of the appropriate platform-specific build subdirectory directory (e.g. build/lib.linux-x86_64-2.7) """ plat_specifier = '.{0}-{1}'.format(cmd.plat_name, sys.version[0:3]) return os.path.join(cmd.build_base, 'lib' + plat_specifier) def get_numpy_include_path(): """ Gets the path to the numpy headers. """ # We need to go through this nonsense in case setuptools # downloaded and installed Numpy for us as part of the build or # install, since Numpy may still think it's in "setup mode", when # in fact we're ready to use it to build astropy now. if sys.version_info[0] >= 3: import builtins if hasattr(builtins, '__NUMPY_SETUP__'): del builtins.__NUMPY_SETUP__ import imp import numpy imp.reload(numpy) else: import __builtin__ if hasattr(__builtin__, '__NUMPY_SETUP__'): del __builtin__.__NUMPY_SETUP__ import numpy reload(numpy) try: numpy_include = numpy.get_include() except AttributeError: numpy_include = numpy.get_numpy_include() return numpy_include class _DummyFile(object): """A noop writeable object.""" errors = '' # Required for Python 3.x def write(self, s): pass def flush(self): pass @contextlib.contextmanager def silence(): """A context manager that silences sys.stdout and sys.stderr.""" old_stdout = sys.stdout old_stderr = sys.stderr sys.stdout = _DummyFile() sys.stderr = _DummyFile() exception_occurred = False try: yield except: exception_occurred = True # Go ahead and clean up so that exception handling can work normally sys.stdout = old_stdout sys.stderr = old_stderr raise if not exception_occurred: sys.stdout = old_stdout sys.stderr = old_stderr if sys.platform == 'win32': import ctypes def _has_hidden_attribute(filepath): """ Returns True if the given filepath has the hidden attribute on MS-Windows. Based on a post here: http://stackoverflow.com/questions/284115/cross-platform-hidden-file-detection """ if isinstance(filepath, bytes): filepath = filepath.decode(sys.getfilesystemencoding()) try: attrs = ctypes.windll.kernel32.GetFileAttributesW(filepath) assert attrs != -1 result = bool(attrs & 2) except (AttributeError, AssertionError): result = False return result else: def _has_hidden_attribute(filepath): return False def is_path_hidden(filepath): """ Determines if a given file or directory is hidden. Parameters ---------- filepath : str The path to a file or directory Returns ------- hidden : bool Returns `True` if the file is hidden """ name = os.path.basename(os.path.abspath(filepath)) if isinstance(name, bytes): is_dotted = name.startswith(b'.') else: is_dotted = name.startswith('.') return is_dotted or _has_hidden_attribute(filepath) def walk_skip_hidden(top, onerror=None, followlinks=False): """ A wrapper for `os.walk` that skips hidden files and directories. This function does not have the parameter `topdown` from `os.walk`: the directories must always be recursed top-down when using this function. See also -------- os.walk : For a description of the parameters """ for root, dirs, files in os.walk( top, topdown=True, onerror=onerror, followlinks=followlinks): # These lists must be updated in-place so os.walk will skip # hidden directories dirs[:] = [d for d in dirs if not is_path_hidden(d)] files[:] = [f for f in files if not is_path_hidden(f)] yield root, dirs, files def write_if_different(filename, data): """Write `data` to `filename`, if the content of the file is different. Parameters ---------- filename : str The file name to be written to. data : bytes The data to be written to `filename`. """ assert isinstance(data, bytes) if os.path.exists(filename): with open(filename, 'rb') as fd: original_data = fd.read() else: original_data = None if original_data != data: with open(filename, 'wb') as fd: fd.write(data) def import_file(filename, name=None): """ Imports a module from a single file as if it doesn't belong to a particular package. The returned module will have the optional ``name`` if given, or else a name generated from the filename. """ # Specifying a traditional dot-separated fully qualified name here # results in a number of "Parent module 'astropy' not found while # handling absolute import" warnings. Using the same name, the # namespaces of the modules get merged together. So, this # generates an underscore-separated name which is more likely to # be unique, and it doesn't really matter because the name isn't # used directly here anyway. mode = 'U' if sys.version_info[0] < 3 else 'r' if name is None: basename = os.path.splitext(filename)[0] name = '_'.join(os.path.relpath(basename).split(os.sep)[1:]) if import_machinery: loader = import_machinery.SourceFileLoader(name, filename) mod = loader.load_module() else: with open(filename, mode) as fd: mod = imp.load_module(name, fd, filename, ('.py', mode, 1)) return mod def resolve_name(name): """Resolve a name like ``module.object`` to an object and return it. Raise `ImportError` if the module or name is not found. """ parts = name.split('.') cursor = len(parts) - 1 module_name = parts[:cursor] attr_name = parts[-1] while cursor > 0: try: ret = __import__('.'.join(module_name), fromlist=[attr_name]) break except ImportError: if cursor == 0: raise cursor -= 1 module_name = parts[:cursor] attr_name = parts[cursor] ret = '' for part in parts[cursor:]: try: ret = getattr(ret, part) except AttributeError: raise ImportError(name) return ret if sys.version_info[0] >= 3: def iteritems(dictionary): return dictionary.items() else: def iteritems(dictionary): return dictionary.iteritems() def extends_doc(extended_func): """ A function decorator for use when wrapping an existing function but adding additional functionality. This copies the docstring from the original function, and appends to it (along with a newline) the docstring of the wrapper function. Examples -------- >>> def foo(): ... '''Hello.''' ... >>> @extends_doc(foo) ... def bar(): ... '''Goodbye.''' ... >>> print(bar.__doc__) Hello. Goodbye. """ def decorator(func): if not (extended_func.__doc__ is None or func.__doc__ is None): func.__doc__ = '\n\n'.join([extended_func.__doc__.rstrip('\n'), func.__doc__.lstrip('\n')]) return func return decorator # Duplicated from astropy.utils.decorators.deprecated # When fixing issues in this function fix them in astropy first, then # port the fixes over to astropy-helpers def deprecated(since, message='', name='', alternative='', pending=False, obj_type=None): """ Used to mark a function or class as deprecated. To mark an attribute as deprecated, use `deprecated_attribute`. Parameters ---------- since : str The release at which this API became deprecated. This is required. message : str, optional Override the default deprecation message. The format specifier ``func`` may be used for the name of the function, and ``alternative`` may be used in the deprecation message to insert the name of an alternative to the deprecated function. ``obj_type`` may be used to insert a friendly name for the type of object being deprecated. name : str, optional The name of the deprecated function or class; if not provided the name is automatically determined from the passed in function or class, though this is useful in the case of renamed functions, where the new function is just assigned to the name of the deprecated function. For example:: def new_function(): ... oldFunction = new_function alternative : str, optional An alternative function or class name that the user may use in place of the deprecated object. The deprecation warning will tell the user about this alternative if provided. pending : bool, optional If True, uses a AstropyPendingDeprecationWarning instead of a AstropyDeprecationWarning. obj_type : str, optional The type of this object, if the automatically determined one needs to be overridden. """ method_types = (classmethod, staticmethod, types.MethodType) def deprecate_doc(old_doc, message): """ Returns a given docstring with a deprecation message prepended to it. """ if not old_doc: old_doc = '' old_doc = textwrap.dedent(old_doc).strip('\n') new_doc = (('\n.. deprecated:: %(since)s' '\n %(message)s\n\n' % {'since': since, 'message': message.strip()}) + old_doc) if not old_doc: # This is to prevent a spurious 'unexpected unindent' warning from # docutils when the original docstring was blank. new_doc += r'\ ' return new_doc def get_function(func): """ Given a function or classmethod (or other function wrapper type), get the function object. """ if isinstance(func, method_types): func = func.__func__ return func def deprecate_function(func, message): """ Returns a wrapped function that displays an ``AstropyDeprecationWarning`` when it is called. """ if isinstance(func, method_types): func_wrapper = type(func) else: func_wrapper = lambda f: f func = get_function(func) def deprecated_func(*args, **kwargs): if pending: category = AstropyPendingDeprecationWarning else: category = AstropyDeprecationWarning warnings.warn(message, category, stacklevel=2) return func(*args, **kwargs) # If this is an extension function, we can't call # functools.wraps on it, but we normally don't care. # This crazy way to get the type of a wrapper descriptor is # straight out of the Python 3.3 inspect module docs. if type(func) != type(str.__dict__['__add__']): deprecated_func = functools.wraps(func)(deprecated_func) deprecated_func.__doc__ = deprecate_doc( deprecated_func.__doc__, message) return func_wrapper(deprecated_func) def deprecate_class(cls, message): """ Returns a wrapper class with the docstrings updated and an __init__ function that will raise an ``AstropyDeprectationWarning`` warning when called. """ # Creates a new class with the same name and bases as the # original class, but updates the dictionary with a new # docstring and a wrapped __init__ method. __module__ needs # to be manually copied over, since otherwise it will be set # to *this* module (astropy.utils.misc). # This approach seems to make Sphinx happy (the new class # looks enough like the original class), and works with # extension classes (which functools.wraps does not, since # it tries to modify the original class). # We need to add a custom pickler or you'll get # Can't pickle : it's not found as ... # errors. Picklability is required for any class that is # documented by Sphinx. members = cls.__dict__.copy() members.update({ '__doc__': deprecate_doc(cls.__doc__, message), '__init__': deprecate_function(get_function(cls.__init__), message), }) return type(cls.__name__, cls.__bases__, members) def deprecate(obj, message=message, name=name, alternative=alternative, pending=pending): if obj_type is None: if isinstance(obj, type): obj_type_name = 'class' elif inspect.isfunction(obj): obj_type_name = 'function' elif inspect.ismethod(obj) or isinstance(obj, method_types): obj_type_name = 'method' else: obj_type_name = 'object' else: obj_type_name = obj_type if not name: name = get_function(obj).__name__ altmessage = '' if not message or type(message) == type(deprecate): if pending: message = ('The %(func)s %(obj_type)s will be deprecated in a ' 'future version.') else: message = ('The %(func)s %(obj_type)s is deprecated and may ' 'be removed in a future version.') if alternative: altmessage = '\n Use %s instead.' % alternative message = ((message % { 'func': name, 'name': name, 'alternative': alternative, 'obj_type': obj_type_name}) + altmessage) if isinstance(obj, type): return deprecate_class(obj, message) else: return deprecate_function(obj, message) if type(message) == type(deprecate): return deprecate(message) return deprecate def deprecated_attribute(name, since, message=None, alternative=None, pending=False): """ Used to mark a public attribute as deprecated. This creates a property that will warn when the given attribute name is accessed. To prevent the warning (i.e. for internal code), use the private name for the attribute by prepending an underscore (i.e. ``self._name``). Parameters ---------- name : str The name of the deprecated attribute. since : str The release at which this API became deprecated. This is required. message : str, optional Override the default deprecation message. The format specifier ``name`` may be used for the name of the attribute, and ``alternative`` may be used in the deprecation message to insert the name of an alternative to the deprecated function. alternative : str, optional An alternative attribute that the user may use in place of the deprecated attribute. The deprecation warning will tell the user about this alternative if provided. pending : bool, optional If True, uses a AstropyPendingDeprecationWarning instead of a AstropyDeprecationWarning. Examples -------- :: class MyClass: # Mark the old_name as deprecated old_name = misc.deprecated_attribute('old_name', '0.1') def method(self): self._old_name = 42 """ private_name = '_' + name @deprecated(since, name=name, obj_type='attribute') def get(self): return getattr(self, private_name) @deprecated(since, name=name, obj_type='attribute') def set(self, val): setattr(self, private_name, val) @deprecated(since, name=name, obj_type='attribute') def delete(self): delattr(self, private_name) return property(get, set, delete) def minversion(module, version, inclusive=True, version_path='__version__'): """ Returns `True` if the specified Python module satisfies a minimum version requirement, and `False` if not. By default this uses `pkg_resources.parse_version` to do the version comparison if available. Otherwise it falls back on `distutils.version.LooseVersion`. Parameters ---------- module : module or `str` An imported module of which to check the version, or the name of that module (in which case an import of that module is attempted-- if this fails `False` is returned). version : `str` The version as a string that this module must have at a minimum (e.g. ``'0.12'``). inclusive : `bool` The specified version meets the requirement inclusively (i.e. ``>=``) as opposed to strictly greater than (default: `True`). version_path : `str` A dotted attribute path to follow in the module for the version. Defaults to just ``'__version__'``, which should work for most Python modules. Examples -------- >>> import astropy >>> minversion(astropy, '0.4.4') True """ if isinstance(module, types.ModuleType): module_name = module.__name__ elif isinstance(module, string_types): module_name = module try: module = resolve_name(module_name) except ImportError: return False else: raise ValueError('module argument must be an actual imported ' 'module, or the import name of the module; ' 'got {0!r}'.format(module)) if '.' not in version_path: have_version = getattr(module, version_path) else: have_version = resolve_name('.'.join([module.__name__, version_path])) try: from pkg_resources import parse_version except ImportError: from distutils.version import LooseVersion as parse_version if inclusive: return parse_version(have_version) >= parse_version(version) else: return parse_version(have_version) > parse_version(version) # Copy of the classproperty decorator from astropy.utils.decorators class classproperty(property): """ Similar to `property`, but allows class-level properties. That is, a property whose getter is like a `classmethod`. The wrapped method may explicitly use the `classmethod` decorator (which must become before this decorator), or the `classmethod` may be omitted (it is implicit through use of this decorator). .. note:: classproperty only works for *read-only* properties. It does not currently allow writeable/deleteable properties, due to subtleties of how Python descriptors work. In order to implement such properties on a class a metaclass for that class must be implemented. Parameters ---------- fget : callable The function that computes the value of this property (in particular, the function when this is used as a decorator) a la `property`. doc : str, optional The docstring for the property--by default inherited from the getter function. lazy : bool, optional If True, caches the value returned by the first call to the getter function, so that it is only called once (used for lazy evaluation of an attribute). This is analogous to `lazyproperty`. The ``lazy`` argument can also be used when `classproperty` is used as a decorator (see the third example below). When used in the decorator syntax this *must* be passed in as a keyword argument. Examples -------- :: >>> class Foo(object): ... _bar_internal = 1 ... @classproperty ... def bar(cls): ... return cls._bar_internal + 1 ... >>> Foo.bar 2 >>> foo_instance = Foo() >>> foo_instance.bar 2 >>> foo_instance._bar_internal = 2 >>> foo_instance.bar # Ignores instance attributes 2 As previously noted, a `classproperty` is limited to implementing read-only attributes:: >>> class Foo(object): ... _bar_internal = 1 ... @classproperty ... def bar(cls): ... return cls._bar_internal ... @bar.setter ... def bar(cls, value): ... cls._bar_internal = value ... Traceback (most recent call last): ... NotImplementedError: classproperty can only be read-only; use a metaclass to implement modifiable class-level properties When the ``lazy`` option is used, the getter is only called once:: >>> class Foo(object): ... @classproperty(lazy=True) ... def bar(cls): ... print("Performing complicated calculation") ... return 1 ... >>> Foo.bar Performing complicated calculation 1 >>> Foo.bar 1 If a subclass inherits a lazy `classproperty` the property is still re-evaluated for the subclass:: >>> class FooSub(Foo): ... pass ... >>> FooSub.bar Performing complicated calculation 1 >>> FooSub.bar 1 """ def __new__(cls, fget=None, doc=None, lazy=False): if fget is None: # Being used as a decorator--return a wrapper that implements # decorator syntax def wrapper(func): return cls(func, lazy=lazy) return wrapper return super(classproperty, cls).__new__(cls) def __init__(self, fget, doc=None, lazy=False): self._lazy = lazy if lazy: self._cache = {} fget = self._wrap_fget(fget) super(classproperty, self).__init__(fget=fget, doc=doc) # There is a buglet in Python where self.__doc__ doesn't # get set properly on instances of property subclasses if # the doc argument was used rather than taking the docstring # from fget if doc is not None: self.__doc__ = doc def __get__(self, obj, objtype=None): if self._lazy and objtype in self._cache: return self._cache[objtype] if objtype is not None: # The base property.__get__ will just return self here; # instead we pass objtype through to the original wrapped # function (which takes the class as its sole argument) val = self.fget.__wrapped__(objtype) else: val = super(classproperty, self).__get__(obj, objtype=objtype) if self._lazy: if objtype is None: objtype = obj.__class__ self._cache[objtype] = val return val def getter(self, fget): return super(classproperty, self).getter(self._wrap_fget(fget)) def setter(self, fset): raise NotImplementedError( "classproperty can only be read-only; use a metaclass to " "implement modifiable class-level properties") def deleter(self, fdel): raise NotImplementedError( "classproperty can only be read-only; use a metaclass to " "implement modifiable class-level properties") @staticmethod def _wrap_fget(orig_fget): if isinstance(orig_fget, classmethod): orig_fget = orig_fget.__func__ # Using stock functools.wraps instead of the fancier version # found later in this module, which is overkill for this purpose @functools.wraps(orig_fget) def fget(obj): return orig_fget(obj.__class__) # Set the __wrapped__ attribute manually for support on Python 2 fget.__wrapped__ = orig_fget return fget def find_data_files(package, pattern): """ Include files matching ``pattern`` inside ``package``. Parameters ---------- package : str The package inside which to look for data files pattern : str Pattern (glob-style) to match for the data files (e.g. ``*.dat``). This supports the Python 3.5 ``**``recursive syntax. For example, ``**/*.fits`` matches all files ending with ``.fits`` recursively. Only one instance of ``**`` can be included in the pattern. """ if sys.version_info[:2] >= (3, 5): return glob.glob(os.path.join(package, pattern), recursive=True) else: if '**' in pattern: start, end = pattern.split('**') if end.startswith(('/', os.sep)): end = end[1:] matches = glob.glob(os.path.join(package, start, end)) for root, dirs, files in os.walk(os.path.join(package, start)): for dirname in dirs: matches += glob.glob(os.path.join(root, dirname, end)) return matches else: return glob.glob(os.path.join(package, pattern)) regions-0.4/astropy_helpers/astropy_helpers/version.py0000644000076600000240000000102513336766210023576 0ustar deilstaff00000000000000# Autogenerated by Astropy-affiliated package astropy_helpers's setup.py on 2018-08-21 10:42:16 from __future__ import unicode_literals import datetime version = "2.0.6" githash = "5e30a46dd0146a241f5c7ca8de0cc0144455b2e1" major = 2 minor = 0 bugfix = 6 release = True timestamp = datetime.datetime(2018, 8, 21, 10, 42, 16) debug = False try: from ._compiler import compiler except ImportError: compiler = "unknown" try: from .cython_version import cython_version except ImportError: cython_version = "unknown" regions-0.4/astropy_helpers/astropy_helpers/version_helpers.py0000644000076600000240000002346313467311012025321 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ Utilities for generating the version string for Astropy (or an affiliated package) and the version.py module, which contains version info for the package. Within the generated astropy.version module, the `major`, `minor`, and `bugfix` variables hold the respective parts of the version number (bugfix is '0' if absent). The `release` variable is True if this is a release, and False if this is a development version of astropy. For the actual version string, use:: from astropy.version import version or:: from astropy import __version__ """ from __future__ import division import datetime import imp import os import pkgutil import sys import time from distutils import log import pkg_resources from . import git_helpers from .distutils_helpers import is_distutils_display_option from .utils import invalidate_caches PY3 = sys.version_info[0] == 3 def _version_split(version): """ Split a version string into major, minor, and bugfix numbers. If any of those numbers are missing the default is zero. Any pre/post release modifiers are ignored. Examples ======== >>> _version_split('1.2.3') (1, 2, 3) >>> _version_split('1.2') (1, 2, 0) >>> _version_split('1.2rc1') (1, 2, 0) >>> _version_split('1') (1, 0, 0) >>> _version_split('') (0, 0, 0) """ parsed_version = pkg_resources.parse_version(version) if hasattr(parsed_version, 'base_version'): # New version parsing for setuptools >= 8.0 if parsed_version.base_version: parts = [int(part) for part in parsed_version.base_version.split('.')] else: parts = [] else: parts = [] for part in parsed_version: if part.startswith('*'): # Ignore any .dev, a, b, rc, etc. break parts.append(int(part)) if len(parts) < 3: parts += [0] * (3 - len(parts)) # In principle a version could have more parts (like 1.2.3.4) but we only # support .. return tuple(parts[:3]) # This is used by setup.py to create a new version.py - see that file for # details. Note that the imports have to be absolute, since this is also used # by affiliated packages. _FROZEN_VERSION_PY_TEMPLATE = """ # Autogenerated by {packagetitle}'s setup.py on {timestamp!s} UTC from __future__ import unicode_literals import datetime {header} major = {major} minor = {minor} bugfix = {bugfix} release = {rel} timestamp = {timestamp!r} debug = {debug} astropy_helpers_version = "{ahver}" try: from ._compiler import compiler except ImportError: compiler = "unknown" try: from .cython_version import cython_version except ImportError: cython_version = "unknown" """[1:] _FROZEN_VERSION_PY_WITH_GIT_HEADER = """ {git_helpers} _packagename = "{packagename}" _last_generated_version = "{verstr}" _last_githash = "{githash}" # Determine where the source code for this module # lives. If __file__ is not a filesystem path then # it is assumed not to live in a git repo at all. if _get_repo_path(__file__, levels=len(_packagename.split('.'))): version = update_git_devstr(_last_generated_version, path=__file__) githash = get_git_devstr(sha=True, show_warning=False, path=__file__) or _last_githash else: # The file does not appear to live in a git repo so don't bother # invoking git version = _last_generated_version githash = _last_githash """[1:] _FROZEN_VERSION_PY_STATIC_HEADER = """ version = "{verstr}" githash = "{githash}" """[1:] def _get_version_py_str(packagename, version, githash, release, debug, uses_git=True): try: from astropy_helpers import __version__ as ahver except ImportError: ahver = "unknown" epoch = int(os.environ.get('SOURCE_DATE_EPOCH', time.time())) timestamp = datetime.datetime.utcfromtimestamp(epoch) major, minor, bugfix = _version_split(version) if packagename.lower() == 'astropy': packagetitle = 'Astropy' else: packagetitle = 'Astropy-affiliated package ' + packagename header = '' if uses_git: header = _generate_git_header(packagename, version, githash) elif not githash: # _generate_git_header will already generate a new git has for us, but # for creating a new version.py for a release (even if uses_git=False) # we still need to get the githash to include in the version.py # See https://github.com/astropy/astropy-helpers/issues/141 githash = git_helpers.get_git_devstr(sha=True, show_warning=True) if not header: # If _generate_git_header fails it returns an empty string header = _FROZEN_VERSION_PY_STATIC_HEADER.format(verstr=version, githash=githash) return _FROZEN_VERSION_PY_TEMPLATE.format(packagetitle=packagetitle, timestamp=timestamp, header=header, major=major, minor=minor, bugfix=bugfix, ahver=ahver, rel=release, debug=debug) def _generate_git_header(packagename, version, githash): """ Generates a header to the version.py module that includes utilities for probing the git repository for updates (to the current git hash, etc.) These utilities should only be available in development versions, and not in release builds. If this fails for any reason an empty string is returned. """ loader = pkgutil.get_loader(git_helpers) source = loader.get_source(git_helpers.__name__) or '' source_lines = source.splitlines() if not source_lines: log.warn('Cannot get source code for astropy_helpers.git_helpers; ' 'git support disabled.') return '' idx = 0 for idx, line in enumerate(source_lines): if line.startswith('# BEGIN'): break git_helpers_py = '\n'.join(source_lines[idx + 1:]) if PY3: verstr = version else: # In Python 2 don't pass in a unicode string; otherwise verstr will # be represented with u'' syntax which breaks on Python 3.x with x # < 3. This is only an issue when developing on multiple Python # versions at once verstr = version.encode('utf8') new_githash = git_helpers.get_git_devstr(sha=True, show_warning=False) if new_githash: githash = new_githash return _FROZEN_VERSION_PY_WITH_GIT_HEADER.format( git_helpers=git_helpers_py, packagename=packagename, verstr=verstr, githash=githash) def generate_version_py(packagename, version, release=None, debug=None, uses_git=True, srcdir='.'): """Regenerate the version.py module if necessary.""" try: version_module = get_pkg_version_module(packagename) try: last_generated_version = version_module._last_generated_version except AttributeError: last_generated_version = version_module.version try: last_githash = version_module._last_githash except AttributeError: last_githash = version_module.githash current_release = version_module.release current_debug = version_module.debug except ImportError: version_module = None last_generated_version = None last_githash = None current_release = None current_debug = None if release is None: # Keep whatever the current value is, if it exists release = bool(current_release) if debug is None: # Likewise, keep whatever the current value is, if it exists debug = bool(current_debug) package_srcdir = os.path.join(srcdir, *packagename.split('.')) version_py = os.path.join(package_srcdir, 'version.py') if (last_generated_version != version or current_release != release or current_debug != debug): if '-q' not in sys.argv and '--quiet' not in sys.argv: log.set_threshold(log.INFO) if is_distutils_display_option(): # Always silence unnecessary log messages when display options are # being used log.set_threshold(log.WARN) log.info('Freezing version number to {0}'.format(version_py)) with open(version_py, 'w') as f: # This overwrites the actual version.py f.write(_get_version_py_str(packagename, version, last_githash, release, debug, uses_git=uses_git)) invalidate_caches() if version_module: imp.reload(version_module) def get_pkg_version_module(packagename, fromlist=None): """Returns the package's .version module generated by `astropy_helpers.version_helpers.generate_version_py`. Raises an ImportError if the version module is not found. If ``fromlist`` is an iterable, return a tuple of the members of the version module corresponding to the member names given in ``fromlist``. Raises an `AttributeError` if any of these module members are not found. """ if not fromlist: # Due to a historical quirk of Python's import implementation, # __import__ will not return submodules of a package if 'fromlist' is # empty. # TODO: For Python 3.1 and up it may be preferable to use importlib # instead of the __import__ builtin return __import__(packagename + '.version', fromlist=['']) else: mod = __import__(packagename + '.version', fromlist=fromlist) return tuple(getattr(mod, member) for member in fromlist) regions-0.4/astropy_helpers/astropy_helpers.egg-info/0000755000076600000240000000000013501657425023234 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/astropy_helpers.egg-info/PKG-INFO0000644000076600000240000000755113336766210024340 0ustar deilstaff00000000000000Metadata-Version: 1.1 Name: astropy-helpers Version: 2.0.6 Summary: Utilities for building and installing Astropy, Astropy affiliated packages, and their respective documentation. Home-page: https://github.com/astropy/astropy-helpers Author: The Astropy Developers Author-email: astropy.team@gmail.com License: BSD Description: astropy-helpers =============== * Stable versions: https://pypi.org/project/astropy-helpers/ * Development version, issue tracker: https://github.com/astropy/astropy-helpers This project provides a Python package, ``astropy_helpers``, which includes many build, installation, and documentation-related tools used by the Astropy project, but packaged separately for use by other projects that wish to leverage this work. The motivation behind this package and details of its implementation are in the accepted `Astropy Proposal for Enhancement (APE) 4 `_. The ``astropy_helpers.extern`` sub-module includes modules developed elsewhere that are bundled here for convenience. At the moment, this consists of the following two sphinx extensions: * `numpydoc `_, a Sphinx extension developed as part of the Numpy project. This is used to parse docstrings in Numpy format * `sphinx-automodapi `_, a Sphinx extension developed as part of the Astropy project. This used to be developed directly in ``astropy-helpers`` but is now a standalone package. Issues with these sub-modules should be reported in their respective repositories, and we will regularly update the bundled versions to reflect the latest released versions. ``astropy_helpers`` includes a special "bootstrap" module called ``ah_bootstrap.py`` which is intended to be used by a project's setup.py in order to ensure that the ``astropy_helpers`` package is available for build/installation. This is similar to the ``ez_setup.py`` module that is shipped with some projects to bootstrap `setuptools `_. As described in APE4, the version numbers for ``astropy_helpers`` follow the corresponding major/minor version of the `astropy core package `_, but with an independent sequence of micro (bugfix) version numbers. Hence, the initial release is 0.4, in parallel with Astropy v0.4, which will be the first version of Astropy to use ``astropy-helpers``. For examples of how to implement ``astropy-helpers`` in a project, see the ``setup.py`` and ``setup.cfg`` files of the `Affiliated package template `_. .. image:: https://travis-ci.org/astropy/astropy-helpers.svg :target: https://travis-ci.org/astropy/astropy-helpers .. image:: https://coveralls.io/repos/astropy/astropy-helpers/badge.svg :target: https://coveralls.io/r/astropy/astropy-helpers Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: Framework :: Setuptools Plugin Classifier: Framework :: Sphinx :: Extension Classifier: Framework :: Sphinx :: Theme Classifier: License :: OSI Approved :: BSD License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Topic :: Software Development :: Build Tools Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: System :: Archiving :: Packaging regions-0.4/astropy_helpers/astropy_helpers.egg-info/SOURCES.txt0000644000076600000240000000646113336766210025126 0ustar deilstaff00000000000000CHANGES.rst LICENSE.rst MANIFEST.in README.rst ah_bootstrap.py ez_setup.py setup.cfg setup.py astropy_helpers/__init__.py astropy_helpers/conftest.py astropy_helpers/distutils_helpers.py astropy_helpers/git_helpers.py astropy_helpers/openmp_helpers.py astropy_helpers/setup_helpers.py astropy_helpers/test_helpers.py astropy_helpers/utils.py astropy_helpers/version.py astropy_helpers/version_helpers.py astropy_helpers.egg-info/PKG-INFO astropy_helpers.egg-info/SOURCES.txt astropy_helpers.egg-info/dependency_links.txt astropy_helpers.egg-info/not-zip-safe astropy_helpers.egg-info/top_level.txt astropy_helpers/commands/__init__.py astropy_helpers/commands/_dummy.py astropy_helpers/commands/_test_compat.py astropy_helpers/commands/build_ext.py astropy_helpers/commands/build_py.py astropy_helpers/commands/build_sphinx.py astropy_helpers/commands/install.py astropy_helpers/commands/install_lib.py astropy_helpers/commands/register.py astropy_helpers/commands/setup_package.py astropy_helpers/commands/test.py astropy_helpers/commands/src/compiler.c astropy_helpers/compat/__init__.py astropy_helpers/extern/__init__.py astropy_helpers/extern/setup_package.py astropy_helpers/extern/automodapi/__init__.py astropy_helpers/extern/automodapi/autodoc_enhancements.py astropy_helpers/extern/automodapi/automodapi.py astropy_helpers/extern/automodapi/automodsumm.py astropy_helpers/extern/automodapi/smart_resolver.py astropy_helpers/extern/automodapi/utils.py astropy_helpers/extern/automodapi/templates/autosummary_core/base.rst astropy_helpers/extern/automodapi/templates/autosummary_core/class.rst astropy_helpers/extern/automodapi/templates/autosummary_core/module.rst astropy_helpers/extern/numpydoc/__init__.py astropy_helpers/extern/numpydoc/docscrape.py astropy_helpers/extern/numpydoc/docscrape_sphinx.py astropy_helpers/extern/numpydoc/numpydoc.py astropy_helpers/extern/numpydoc/templates/numpydoc_docstring.rst astropy_helpers/sphinx/__init__.py astropy_helpers/sphinx/conf.py astropy_helpers/sphinx/setup_package.py astropy_helpers/sphinx/ext/__init__.py astropy_helpers/sphinx/ext/changelog_links.py astropy_helpers/sphinx/ext/doctest.py astropy_helpers/sphinx/ext/edit_on_github.py astropy_helpers/sphinx/ext/tocdepthfix.py astropy_helpers/sphinx/ext/tests/__init__.py astropy_helpers/sphinx/local/python2_local_links.inv astropy_helpers/sphinx/local/python3_local_links.inv astropy_helpers/sphinx/themes/bootstrap-astropy/globaltoc.html astropy_helpers/sphinx/themes/bootstrap-astropy/layout.html astropy_helpers/sphinx/themes/bootstrap-astropy/localtoc.html astropy_helpers/sphinx/themes/bootstrap-astropy/searchbox.html astropy_helpers/sphinx/themes/bootstrap-astropy/theme.conf astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_linkout.svg astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_linkout_20.png astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_logo.ico astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_logo.svg astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_logo_32.png astropy_helpers/sphinx/themes/bootstrap-astropy/static/bootstrap-astropy.css astropy_helpers/sphinx/themes/bootstrap-astropy/static/copybutton.js astropy_helpers/sphinx/themes/bootstrap-astropy/static/sidebar.js licenses/LICENSE_ASTROSCRAPPY.rst licenses/LICENSE_COPYBUTTON.rst licenses/LICENSE_NUMPYDOC.rstregions-0.4/astropy_helpers/astropy_helpers.egg-info/dependency_links.txt0000644000076600000240000000000113336766210027301 0ustar deilstaff00000000000000 regions-0.4/astropy_helpers/astropy_helpers.egg-info/not-zip-safe0000644000076600000240000000000113336766210025461 0ustar deilstaff00000000000000 regions-0.4/astropy_helpers/astropy_helpers.egg-info/top_level.txt0000644000076600000240000000002013336766210025755 0ustar deilstaff00000000000000astropy_helpers regions-0.4/astropy_helpers/licenses/0000755000076600000240000000000013501657425020124 5ustar deilstaff00000000000000regions-0.4/astropy_helpers/licenses/LICENSE_ASTROSCRAPPY.rst0000644000076600000240000000315413336766207023762 0ustar deilstaff00000000000000# The OpenMP helpers include code heavily adapted from astroscrappy, released # under the following license: # # Copyright (c) 2015, Curtis McCully # All rights reserved. # # Redistribution and use in source and binary forms, with or without modification, # are permitted provided that the following conditions are met: # # * Redistributions of source code must retain the above copyright notice, this # list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright notice, this # list of conditions and the following disclaimer in the documentation and/or # other materials provided with the distribution. # * Neither the name of the Astropy Team nor the names of its contributors may be # used to endorse or promote products derived from this software without # specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR # ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON # ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. regions-0.4/astropy_helpers/licenses/LICENSE_COPYBUTTON.rst0000644000076600000240000000471113336766207023536 0ustar deilstaff00000000000000Copyright 2014 Python Software Foundation License: PSF PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 -------------------------------------------- . 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated documentation. . 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Python Software Foundation; All Rights Reserved" are retained in Python alone or in any derivative version prepared by Licensee. . 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python. . 4. PSF is making Python available to Licensee on an "AS IS" basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. . 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. . 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions. . 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between PSF and Licensee. This License Agreement does not grant permission to use PSF trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party. . 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this License Agreement. regions-0.4/astropy_helpers/licenses/LICENSE_NUMPYDOC.rst0000644000076600000240000001350713336766207023271 0ustar deilstaff00000000000000------------------------------------------------------------------------------- The files - numpydoc.py - docscrape.py - docscrape_sphinx.py - phantom_import.py have the following license: Copyright (C) 2008 Stefan van der Walt , Pauli Virtanen Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ------------------------------------------------------------------------------- The files - compiler_unparse.py - comment_eater.py - traitsdoc.py have the following license: This software is OSI Certified Open Source Software. OSI Certified is a certification mark of the Open Source Initiative. Copyright (c) 2006, Enthought, Inc. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Enthought, Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ------------------------------------------------------------------------------- The file - plot_directive.py originates from Matplotlib (http://matplotlib.sf.net/) which has the following license: Copyright (c) 2002-2008 John D. Hunter; All Rights Reserved. 1. This LICENSE AGREEMENT is between John D. Hunter (“JDHâ€), and the Individual or Organization (“Licenseeâ€) accessing and otherwise using matplotlib software in source or binary form and its associated documentation. 2. Subject to the terms and conditions of this License Agreement, JDH hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use matplotlib 0.98.3 alone or in any derivative version, provided, however, that JDH’s License Agreement and JDH’s notice of copyright, i.e., “Copyright (c) 2002-2008 John D. Hunter; All Rights Reserved†are retained in matplotlib 0.98.3 alone or in any derivative version prepared by Licensee. 3. In the event Licensee prepares a derivative work that is based on or incorporates matplotlib 0.98.3 or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to matplotlib 0.98.3. 4. JDH is making matplotlib 0.98.3 available to Licensee on an “AS IS†basis. JDH MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, JDH MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB 0.98.3 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. 5. JDH SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB 0.98.3 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING MATPLOTLIB 0.98.3, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions. 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between JDH and Licensee. This License Agreement does not grant permission to use JDH trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party. 8. By copying, installing or otherwise using matplotlib 0.98.3, Licensee agrees to be bound by the terms and conditions of this License Agreement. regions-0.4/astropy_helpers/setup.cfg0000644000076600000240000000015313336766207020144 0ustar deilstaff00000000000000[tool:pytest] norecursedirs = .tox astropy_helpers/tests/package_template python_functions = test_ regions-0.4/astropy_helpers/setup.py0000755000076600000240000000364113477530461020042 0ustar deilstaff00000000000000#!/usr/bin/env python # Licensed under a 3-clause BSD style license - see LICENSE.rst import ah_bootstrap import pkg_resources from setuptools import setup from astropy_helpers.setup_helpers import (register_commands, get_package_info, add_exclude_packages) from astropy_helpers.version_helpers import generate_version_py NAME = 'astropy_helpers' VERSION = '2.0.10' RELEASE = 'dev' not in VERSION generate_version_py(NAME, VERSION, RELEASE, False, uses_git=not RELEASE) # Use the updated version including the git rev count from astropy_helpers.version import version as VERSION add_exclude_packages(['astropy_helpers.tests']) cmdclass = register_commands(NAME, VERSION, RELEASE) # This package actually doesn't use the Astropy test command del cmdclass['test'] setup( name=pkg_resources.safe_name(NAME), # astropy_helpers -> astropy-helpers version=VERSION, description='Utilities for building and installing Astropy, Astropy ' 'affiliated packages, and their respective documentation.', author='The Astropy Developers', author_email='astropy.team@gmail.com', license='BSD', url=' https://github.com/astropy/astropy-helpers', long_description=open('README.rst').read(), classifiers=[ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'Framework :: Setuptools Plugin', 'Framework :: Sphinx :: Extension', 'Framework :: Sphinx :: Theme', 'License :: OSI Approved :: BSD License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 3', 'Topic :: Software Development :: Build Tools', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: System :: Archiving :: Packaging' ], cmdclass=cmdclass, zip_safe=False, **get_package_info() ) regions-0.4/docs/0000755000076600000240000000000013501657425014024 5ustar deilstaff00000000000000regions-0.4/docs/Makefile0000644000076600000240000001074513336761120015465 0ustar deilstaff00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest #This is needed with git because git doesn't create a dir if it's empty $(shell [ -d "_static" ] || mkdir -p _static) help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " text to make text files" @echo " man to make manual pages" @echo " changes to make an overview of all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" clean: -rm -rf $(BUILDDIR) -rm -rf api -rm -rf generated html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Astropy.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Astropy.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/Astropy" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Astropy" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." make -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: @echo "Run 'python setup.py test' in the root directory to run doctests " \ @echo "in the documentation." regions-0.4/docs/_static/0000755000076600000240000000000013501657425015452 5ustar deilstaff00000000000000regions-0.4/docs/_static/region_ds9.png0000644000076600000240000120104113336761120020213 0ustar deilstaff00000000000000‰PNG  IHDRóAmp1sBIT|dˆtEXtSoftwaregnome-screenshotï¿> IDATxœìÝwxUÀáß¶$›Þ ½6!ô^BU)zQ¦tᣉ‚€( ]Q)¡ˆ ‚ Jï „’P¤·„ô¶õû#…$² 9ïóälfîÜ9÷ÎìÙ;wf§OŸ¶X,RÿMý¿Ùl~èµôË !„B!òŽB¡ÈðÿÔß•JåC¯) Ô™“x‹ÅBBB÷îÝ#66–ÄÄDL&S–ɾB!„"ïdNÖU*vvv8::R¨P!´Zm†eÔ§OŸNKÐÍf3wïÞ%&&†&MšP·n]ÜÜÜP«Õ¹OB!„B¼ŒF#œ9s†mÛ¶áääDáÂ…Q*•ÉI½Ñh´˜ÍfŒF#ÁÁÁ8;;ãëë‹ÙlNûB!„B ¥R™ösúôiôz=¨Õjz½Þb2™¸xñ"†²eËb0d*B!„Ï…BF£!88•JEÙ²eQšL&¢££¹~ý:¥J•B¯×K"/„B!Ä3Æb± ×ëñ÷÷çÆDGG£ˆµ\¸p'''|||$‘B!„â¦P(¸uë±±±É#ó÷ïßÇÍÍMy!„B!žq‹777ÂÃÃQFâââ°³³+èz !„B!¬`kkK\\JƒÁ@RR’ŒÊ !„BñIJJJ™7]!„B!DFԩɼŒÌ !„Bñü0É7ÀšL¦‚®‹B!„"L&j³Ù,ɼâ…aN¸ÊþŸÖ²ö·#œ»FœQ‰“;Þ¥+Q·áK´kSbZEº5LÜØ0Ž_…δúr5ÿ«¦}dù¦èólZËÏ»ŽqîF4zTØ{ùR£þ+tìÒš^6¤•ngó ŽL= ží°n°¶ù¸ïÏý¿,íýKo@¹Á«XÖΕµëZ’¸}ô'¾ùa+‡C¯ž`ƒ»o^»?oú¼81B¼ðÒ’y³Ù\ÐuBˆ|g‰ fÙð¡,;Ÿ~ÃLbLÿžÜÉ¿×hÚ¦>ÅÒ¯d¸ÉŸ¿„¦üÍ®ŸO2´jÓçû)åDüž?\ÁÉ„ô¯›ˆ¿sž½ϳwãFÚNœÁȦÞhò~÷^ –XþY2„«/ó`r¨žûö²üG93âf´-"ñB¼Ìfsr2o±Xdμâ?ÎÀ•3Syê¿Õ›7jùSÆCIÔÝ„þ}ˆ³ÎoPÎÎBúÓ¡þê~¹òà÷øƒ?q,ª\2f󆛛?j'“;?^§=+–ÆÝt‡Ð“»Xµìw.›®³iò\¼Òßß…ŃŒ4ù<üœ‰Óï««÷]y=SSùÂMða÷úSÜæÄÏ ˜¹é2‡¿ú’u?£¥§2ÿê.„ϋłR’x!Ä‹ÁÀ­àÛ¨k eBïWiP±>>%ð«R¶½†1úÍ’™¦h$qqÛ6nöõzÑÜ H:Æú£d¸ži‰æÈ×_óWàÒŒO¾›ÃèŽÍ¨ã_šrëÒªÛ–~÷!œ®²ò«mÜ–Ù¹`&"ø×_fܨÔõ-B±²Õi;øc–ôÇX»ï^!ij¤AÓ—0x‘‘‘i¯EEGóþ°á4húÒ•­dT^ñPáZ̸‡ñør–ìð¡_³Ò8>n7ñ›~¿ ØQóµWiçñ3¿oŽäøÆCÜkÖ ¯”u-±§ùé@ÞíCãBꇊ²-ò2CúmfßçÁ˜ÏneX:Êb›†«¬x·7KnW Ç»•¹sà ÇÏ]!\á®agÞkíÁ…[Ø~ø —Â’pð©ÀKobHóbØ* yºÏO,ÿå§Ïœåü­XTN…)Uå%z¼Óf¥íy°Ë&îÿ³yK·rôüUîëmp)êG•áì=xßV±´WÊ\v3QÁ?1oÉ&ž¹J„Úƒ’åkòfß÷hWÑ5›ùîfbC~cÑ×?q øw N)YãÍÌËYH¼q–¬ä÷๞ˆÂΟRx©÷púÖvA©H¹"¢R¡IqDíIõê^z‡‹/ÿ†N­“B<=¥K•âä©Ó 1’¹³>G¡P0dähB/\ d‰¹.×b± NMä%¡Bü·ÙP¶ÝÛnɾØKüøi~œ[ŽÆ-[ðjó&Ô)ëš19âƒag`S™–þ”³¯ëæ-Džù…=·_¡ƒOr ›të$õE©[Ñ E–SFxVoB‚¹Àuþ¹®§½gSMR×5œá‡EgP*s8çw,`ÄŽÔT€™Ø[§ùyÚ(ìJ,ç]òuKÔa~ù#ײe©^ÝÌÝsgÝ·š‰]ÄüÝ'4÷TFnÿ6‘^3Ø—¬Fã²NÄ_;ËÁƒ÷Rê•Z3á{>ãI8)M)ÃMþ=¹ÙáüÔoø¨® Y.2¶{:}&ÿA€Ú•¢EÐ߸À½ÌSŒN3èx~ K~ÕÖÙ ¢#¹qî ÷íìPX¸TjH9εi ª1¹W %m¢¹q~/ßï¾€ñÎU" õp|ø3•BˆYÓ§1xø.^ºÌà#Q(\¸x o//fMŸöDy¸œê„/ µ×+L^ åÛy‹Xyä.æ˜Pv¯ e÷ºy8UhËûÃûѪŒ]òÓf,±ü³i?Ñ€¦Ò+TvR`çûõ·°%:”ŸvÞäõnÅÑ–øâÐâ¢}ôµÊÁ3e´8‰˜¤ì'‚¸¾4ŽE#SÌ&žãóßcðÆ» ªÀ€Ù“éXÁ UøNþ÷ö§ì¿Ë#wè¯+.õ?aûjT)NÌQßm»Žðã‰H^jîŽ2î–,LNä½ÞœÉ²AÕpQúK,yû=¾»®" gX>÷O±¥Öȯ™Þª6–DBV ä﮲uÙŸô®õ&E²Úõ„`–ÎMNäG²h\ JÚ*@™¥ïöeù‹îäX@!:.ø–!~¶`N"ân$êBvhŠ¿É¸>{xç›®mþŒw6g±Mcy®ƒâR¸P!æ~1+-¡ð*\˜¹_|Ž·—ו-w !^ l‹5¢ßg+ù}í<¦ôz%“3sfÓ†|ÊÖ;É߈m‰>Á‡’KS.° ŠØXbŒ>4¬fÀ¿¿îàŠ>¥T­+ɯFq#ÊðÈ­›âï €=Ù?ˆÑ©xY¼ì” t¤BÓ¸Xl)^ ¨<ªñR™äecîF?˜Ç¯„Ø‹ùeí÷,Z8Ÿ¯¾ÛÃÝ”?FÜŠÁ$];Èñ€2tíX99‘„¤k{9p@MÒ‰ æ|ñ%3¿\ȆДo¿zŒ«IZw‡"JнïËɉ< 2?HíéOEW€{¬ÿx_¬þƒ·Í¸x{á”.[|»~Áʉ]¨[Ò%ezÏ€WèPß5y{ìe¨JñŒÑ¨5ØÚ>¸3ËÆÆÍ—+§;!Ä H­§M;ùÑ´Sî]Á˜qk8wï·Ý¤ù[ňþëgަ$¨gæ¼Cë9™Š¸µ­ÿvãƒò¶ØxW¤”Ízîèï±wÏ5ú•÷ÍâYçf"Oíã2€²4µŠÙqÖ×Xm›|Â6'g0JP¨±IIrõ ÆädÞÅÑÃöãÕ,˱˜ÍXS\xò µ;EÿÁÂs—hâ8ùǯœÌ¼€>Ž„G\h0Å„ *Di÷Ç¿å(ì«2dæh´s³þÔQ~üú(?~­¡x`W>x¿+õ §CFŒâß+WÒæÈ_¹z•!#G1÷‹ÏñpwÏuÙigV™3/„x1©ñ¬Þ–6¥ÖpþÄßÅd cÿÆ0>v½{lßBŸá±sàµÚZïKàÖšYüPwo8f¸ôi ÛÏ¢Å'0¶µ^£†‹"Óy×’Åc‚Ì¡OÿúƒåžsŸtyÓ¼ xÐrô$Þ ôÅÛîkû¿ÅW—H~$¤Å‚Ò±0N@¢1œëÑF,öªådÚŽÒ1yzP"¾ [5v^Y%ÿé™*m;¦(îÆš°Ø§Þ5lyh;@[¦9C¾lLÐ#ìܵ“-›öºï;Fß²á‡ù)©0c4+P+ Ô Â‚)ì «öÅZj6+ƒÍ‹ô˜O!Ä3o䘱i‰üœY32bW®^eć±|É¢\—-cBˆƒ%–£Ÿ¿G¯QŸóÍ/ûø;ä*·nÿË©ƒ¿³ò‹ñ̽ ¡Leo”wö±ñŒ°§éÔìùãwö¦ýlá‡>%ˆØ³™Óñ€Ò•º}Þ¦²0‡²|pF-þ‰GÏpîÔa¶­Ã ·'³5Pз_}<òéìkŠº•2ŠîA@Õrx;¨Á”H¼>ãr¶Å©çp™å‹~çßÄäÔ׬&Ö˜yÙÔv¸À²E¿s)!Ý„t³ýcæ§?ØÎ–.þ“kI)·ÖšâˆÏ<#Ép—£{s) ÜËÒá½qLX!ùo7Ïs/¥^I¿§o×áÌþå ÁWorñÄf™ÎÁD x{ÞªìøÐ!„(H¡.à[¶,sfÍÄÃÝwwæÌš‰oÙ²\¸xñ‰Ê–‘y!Ä ÁqŒ ?.sI™KÇ·±"‹eì«÷åƒúŽÜÜð+¡/Ó±²CÆ/8BM±—;PiÙ,NÅìgã?1T¯ëˆ¦ØëL™Æèÿ­ã¼1œ#kçsdm¦ Ø”§û”‰t(¡I>ç¦mOZÏøåIéÏ0`ÿ`d>ó—NÙ–lL-‡ÝìŽ aÖÛ=ø¹œ'†kç¸~u ;z~™“w¶w=|··-Q7î‘yûvôùà%Mùƒð=³èµgÞ®(ã¹c¡æ„UÌjä’u~;»¦Ómß"|¼m‰º~7å¦áÛ‰;ûOÚF$É÷!¸IDJeœë5§¬‹9ŽS6s!,’ sN³!C|+1hBçäåä-Mñ Ù³c{ÚÿSsnw77–-^˜áµÜ‘y!Ä AéR›ÓGÓ§umtEÝqL™~mëäA©ª¯ðî¸y¬™ú¥¸Îï[“¿òµx›¶”·Ë¢,zt¯g$røçD™”¸ÕìË‚U_2²]}ü §>Ï]…£·?M:gáÊÙô«áš¯'^¥[}ÆÌB›€BØéøz…ÿ›ôií“yI<Žä‡%£éPÛû8nßGS´4…ª  Æ£XùÍ:×+O1Wá·o–¤¥h…:øÙyôà|¦íhc¹u=ÛRuy­Eét±° r¤Ç›õð/ê†mB$IZ<ŠU Y¯Y4¢®J@á@a ù²_KjûÂPh Sñ¥ÞL_>Î¥¾[A!þËÁÁÁ–ýû÷Ó©S§‚®‹Bˆ‚–xši]‡³5tÃV±¸µ§Œú!Ä3jíÚµrŽBñ€9öWbì(\Ø^Þ$„â'çi!„xAéïæï‹á$¦Ì‘±è¯óûâo9 ­Nˬæ !„x¦È °BñBŠçÔÒ‰ ÛJg||l‰¾y8 € ßïGçÌÏBñ¬Qß¼|« ë „âi3›±¯Øœ&·ówèMnÝˆÆÆ­(~åkóFï´(ë(—n…â9 èX»§¥Zë Ü¿ ë"„B!„°ÒºuëPV­_…­«~/èº!„B!rH]BW‚2W|e^¤B!„ÏelT<®žÎ]!„B!D)5'ž,èz!„B!rH}hû!¿Ö@¦Ù!„BñœQ¿önknGÞ$,,¬ ë"„B!„ÈEpp°eÿþýØÚÚt]„B!„VJJJzð °o½õVAÖE!„B‘_ýur2Ÿ:_>$$¤@+$„B!„È^PPÞÞÞ(M&“Üü*„B!ÄsHi41›Í]!„B!D) ƒ$óB!„B<‡”ƒ£ÑXÐõB!„BäÒd2t„B!„¹ T©T(Š‚®‡B!„"‡”•JUÐõB!„BäÒÆÆÆÊd>‘SŸ4D§Ó=üóÆJnšâ9<¼º¶+¸–åïùå1uÓéè°á.ºÅ71xu/3;DŸòJæ:¸¶u_­9Iô“Ü'lºËÆîнô%çõY-Ç‘1uÐUÄŸQqO)n9eMø¯1wåGŽÉðó׉`.ÞŠÆn¹˜‹Ç8rêIù\#}Èl^~D_Oýi³ü*Ïõ0¦pŽ,C—¦Õ’÷É¿ Ztcð´ \LÌË =­sT s ç7ÍâƒM¨æ—ÜVU·cÐô œŒ´¶O¹ÎÉêÎ\Sû´fâl_¢2¿Xbùç›É|wΛº•Üy~¯·%pzNOz.¾Žÿýù¸QYœïpéìQþØñ+çúµ£¬Ýs85Ðt»2hÝ5¼t¥ß¤ê”p4p÷üA~ K·.m‚SA×ÓZÊÎH€‰ø[ÇØ03Þ¾Žío?У„:ûõs¤€ß[2PâV±>ÅY¾³1¼[Ò-ùp7…ñ÷Ñ»„î¾Hb[OìÐsíÐ)âTþ4*m—\„U}¡WžÂqpöG¶Ý¸ÂO¿^潡å±yâRŸ–g©_QpržÌÛ¥nË6:dõG-•G­es^Õ.§[7kå×>(q¯ß…ºšaüºéø>ýg;£hÒ©ΊŽcvrg‹)‘$ì°{~³KPØâäê†KÊ>¸»9BÜin†Eað*ŒB…Cñ T| UQ:•£á«å2½jæþ®±L;gÆwÀ\†×pÌÏÏù+á4߯¾ˆc‹E¬ø¬).i;òƒÆš0=—÷ø˜¸³y #ÖݤâÐù®©»Ñ¦=½öcûžjBòÄÇ¥5š½œrhA3¿Xš÷ÜÀÚ]·éúV±<þ0ùlmŠÕ¡²ãBì¹DbËhKìyö\ó Y—B8x˜ú:”³Lœ>xÊôÀßIÕ}á©ñœ^¿pUij{]æÈÏ?sqÀ(25=»ž­~!DAIOϳ7Gk.¸¹ó+Þ­t:tÑåk9÷¾…ÖÅñoÓºFòeá—ßý‚Ýw2OFH¿ñÞˆÞÛàìÇ4­|)´Éôà\M¥Pº×¥s][nþú 2\"áïu»ˆvnBǪNdÇÇÇ-þðHjéÚ°üjÊ Æ+,m£C§ëÂÆ{)|õ!Ì~YGãiÁäéL… bÙÝ7]ûål_>’võ+àW¡5 B‰8ºŒ±½ZÑ JÊ%å¦Ý˜°þ<š>eÝ«8²q"T@§«DÓ>ó9i"áâF&tn@€NG@ãÞÌ=‘é’þSì[J%j%vìdžfc"òüQŽß!òÎ%‚O$OÏ9vúwòþ{L·å#6Qe4sTÂ>µZ–Xέ›@·¦UÑétøÕjÍ€¹»¸¾Ûg»Ì“¶Kb¸ NE óÐÀ£R…*ÃkníšÏàvTÒéÐù× i—1¬¹¤LVô¹,+÷ýÈx•Ÿ—ì#±ÈÛ|Ü;]ò–B¡-G‹¶å°ëÚ,3kÛð¡ãÒê¹Ù²/]‹â@ô­¨tS¼¬ˆ¥é>G¤eõäóró¾sرsJ6Ós²Ï+ØùÇ´¯_NG­×GšÀ´åh\^Aĉ¿¸23%ñò^ÎYüiÓº)…ïàtTÊqžÊîPð¬UBj¬ï 9:r)îëvD`×p(cÞ« 7åç éßݬaN53÷~éEEÿN¬É4?3ñô4ëê0æp`&úä÷Œîr|ëtT |AKCRγ™ûEvË? 9=¤Ä¸Ý7l^ð>­kêÐé*РË$~¾œødýT¼0r~-Ôb .:šè´ãOÆÁ ­UÃ0fîïOÇþ±k1˜©C«à¾Ÿ¥ÓÆÓ-\ËÖymñz’ᜇê ÂÖÑ[¥‘ëë> ×̨ðÖÇ,lR˜û{¿áãφë# ÔRuüZfD½Éè›}Y¹è ¼” 4.^¹» ©p£N—úØ ÚÂÆaTN¾äj‰>ÁÚݱ¸¶èDǬVÌ>n…}›â§ÚÊ®à(Þ.áQ§Ùu „çãy³#¦ðì»nOå†%±ËMýSYÓNÉdÇ>|¼t;þö ˜=DÿvMõî|ؽÚ$® bî¸^$xmcFC—#Éç1rY-ºžÃ; ‡XòÉ\Žˆ¤Îõ#ØwøÙ½cØ¿ðSæþŒZ;>£ž“ª=Qß‚ÙlƬ°`1‰¿[ K:¡yÜ›jÜ5®Ø¥”5ì‰çî¥Pþ µÁ©b1´y5-Ép…5£Æò‡)O¿ì…oÚ¨š‰›Óå‡)ÑáCæ¶(Fü‰ÕÌœßnÑ?ðó¸Z8)¬Y&¥¸\µK.hKR§4\ý s+Œ¦{³ÊqȪñL„íøˆöƒ6¡jüãçÕÂË|ó‡öq5Â(ˆ¾jeŸK“?ýÈyšÀ£ssÊ<öàËA{äf‡ŽË¼›cŒ¸Â} p”7kbiäêªAôžBõ>SÓÀ“ˆCßñÉG'¹KÞÄéôl>.<ˆOVíÁOyžU£ú3áýbTÛ4˜ò¹O¢t! °ÌÛÇ™è÷(íaæÞßLj*ÞžJ:•lW²çBor éêAN'Øаtò¾µ}Áêã ÷bþ^ËŸQZêwª‹_@ Õ&ÿ_7žgh@åŒïÙÆÐœÃcM‰g£^4¶ÀÊ­×éðnÉ”>ÏéÕ¿pÛ«-Ý*;@Ü>{ïv”ëÄ…”°‰åfè1ŽÆ$d}\Ü_9[>'²Ì/bˆÏp›Áœ?‚¿`ªûpæü:ƒŠÊó}Ñ= xnù„ÎÏãÕHñ4åüLž´›ÁMj¥{AKóeû™×ÀŠ9ú‹¬œ¶‘ÈZSøýËNQ4 ¦O8Íßýе—ZòA¹'¸ÐüPÝŠ3`Ó†–aÅüè_ú킇¨W Û/Óë£ T`ëæM!%غS¤Xñ”:ç–—Úi¨íÏoÏ1¢rU´Xˆ9¾–½qî´îP)eŽe&ÖÄ­tEš”1²h×_­%t'!ôô=Á{þ%1°"ús; UèèV>Ë­XÏš> ªÂ¨™ƒx©pº€µŸÀäôå4¬O‰ÛMøíQ¢_~pÙ\”A‹gйˆ hLéÛ»i»p51Óv0·7* Qñëìj·‘M!‰Ô«¡Íÿ¾eŽ$ôÄ_^²+䋯—Ýã§³(](QÚ5€ >Å=¸s6‚H}Q´y2ï;s_eÊ-­æNçÍ¢ééij,Ÿ»sàç|óq[ «€Fõ(ohC»¥_²½ï÷´w±b¯Ôä¢]rCS†·f~ȉ÷¦óÍÈ.|8­BýWÚóNŸöTOM@õøþ³MDVŸÈ¶Ý(žòrãíÓŠ*imŸK•OýÈuû€GÇXÓf^O°NVÇenYŒ$ÆÇ‰øÛÇX5é[®éĤ慓§ØXËâgY±ø8öm¾fÞÈFÉíQ¯:>a¯ÐkCÅI[—±Sߥ›ð¤Ï¨¶üÐý7vÝHùÒ¹ý0£¡H­ª8›w±çR"­Ýõœß{ —U)äT”†e’˜è:úz¾Ü?yˆ›”¥.ùühu_°ö8È-K4¯ÝIŒ¶j¹ rhL§J>Úú#gGT¦ZúÃ7Ûjr|¬)\ëðVKWÞ ú‰Ë=‡PÎ,ÑÇY¹í>%zvÂO Æ«ÁœŒôäµïÓ±jJ…›óæ#vÉž³ås$Ëü"EÉ”­:<¢|eF|Ò›Z^* =?ËMÇ2÷·÷©ÛÉç9¾J< 9TUeøÂå,_žòóí7 ©dÝ8¯)ì;¯@åÎÍðIë™ œ«¼J›«8ýd—”2×mùr–7‹Å5˜ÂNp䎚êíê&'òJWj¶«õd£Ô9¤pªAçFÜÛ¾‘s €%š¿‚öïÙ‚ö²N~¬Š›Ú‹Zu }ü ×õz®î?A’ßk¼ÖºᇎqÏ”À¥Ý§H,ÞÊOz§ª5} Lª¹g<ý˜£O²zâÛ¼Z¯rÊ0jÐ{s4 7BK?… lKê§ _Øà]Á(Ç«u ¥Ðl|ð&Š‘ëcô$û¬p¢xy?üüüðו£L17,÷.rþZÌã§”Ø9“~0M¡±Cƒ‘$c^Lµ±{|.ƒçœÁ«Ël&5÷ÌpÂOîóJªt¤PÚ´ø¶jIóv_L´j™4¹h—ÜQàðKväçESòV[ª9\á÷åèÚz(¿Ü2¥ìß_쾦 Z÷{D^cuŸK‹Y>÷£lä¨=r³N™‡Ë\KÚÅ ÀjT«^“­ú1ÿo_†-G «2¥^ÙÇÒö7GïÙP½mµɞ‰J­ke=°‘›}.H@º‘™“«£ IDATMgi<‰äúõQЖmŒŸ2Š¿ÜÀx‰}ç@X;¥ õ¼¸sð¦xBö\ï:TõÈiÜ­;rËsŒ Ýq84êL 'EòC:×D¶Ï$d\ØŠæôXªt{ï+?²ö|"`!âàwüSžÎo”ÁP{T ¢Kë'LbÑ/û9/ñ±#ì9]>G²Ê/–ÏgPºäü‰Î¥›RÝóAQ¹W§ii3çv_ÌÇi±â¿"çí5žÔ©Oý\ÜdjнC <²~#þ{ùûñ˜ñÈý'ÐÇÔMNN¸eUÓ¸Á™ÐÜn1çÎTíܧmÛÙpf UËeí wl‡ÿ#2­[©†•ЮÜÏ?aí1î¿G±VU)[#„B³vr&¼!W„áZ³.EŸô.;kú€Ö5ã4Ó-6îÁ¤³5é;j.Sü¼q±3qaq†O˜þ gç˜aލB­D-Žv T¨4¨0cJy“È÷¾¥PcïäŒsJN..Ø›Oqúæ5î{ùSèQCl åC#÷ ,X,O>*oŽØËÔÁ˸Ræ=ÖŽ®‡K¦Ïh¦øpâ°§Œ›m†:¨½p&û1&«–IûÌŸ‹vy"wüšv¯i'ÀÀ­mci?øf-?Ë+c+¢Œ #{J{j³¾:’“>—ºJ>õ#µKqÜ+—ÂÑS‚G]³°®=Ô¹X'¥2—OBUQ ‡SÙNOø™Í̾‘/‡.¢áC ÐZKCÜ}âqÀÃ)ã>©œ ‘åŒÃ9Úg]Æ©p % L<éçi…KKÁ—ûÏÖêÇ¢ŠÓQçˆEkWÂîû=„Fø±?8mÅ”Hï°¶/¤Éæ8ÈÝ`”…¨#AìMÐR¿UYˆ‰&ÐTjC嶯?ÅG5j?ø@•] sq¬Øùu¢Séü°úÃ*”dÏûÑWO«ÔOçµøß·Ÿb?c ‹GýÄ—€£® ƒ§L¤gç‡G#sº|Ndù¾Mœp'% V?ÑâZW´éc¬´ÇÕ#b0äóÒÄó/¯ŸöX*PQsÒj&×Êœ *±+œ—’Tö8HTBÆÑ sB$ X'¿8UíH3çÍìØpŠþƒ8èC·7u<)[7¿f”ãSþ8öÆ]©SÛ ‡T±ù‘ÇŽrë_ CÊ<µ+éÏ=–ˆ¿ØpÈHY3ÑÚ#åoqÜÓç͘ÃÓï[Jlím€Dâ“Ì`ó”Ï´¦;l0‚ ÷+1rùûTÉ|©1‰',2 öiíaŒ¾C4ZJ:©¬Z†gâ, >ºñ’û/¬;w=qp,„ñÜ KÈP÷T¹ésùÕ®iê ³öîàRb5qZ×¹YçAæYOÕxàW³6µ€:õ¨êr—}Íg¿væÛ>VÅÒ&Ú{âÉøéÏsØÇlú™è·jojUwòm7ÿœ¸Ïu·šTMYÕú6¤lÒ\öž8ÂÑÛà;¨|Zblm_ÈÚÃÇA®Îç–¯9@"Iü9¤MÙ±Ž“ãjS÷qŸ¨2—Ëó»¦4¯w`Þœ•êQ“ï*¨3óe¼Óº¹GÿLXÞñ†.ùÓ¦0µ¿–Š~ÂÃ3ùrº|Þ²îüñˆ›Î£nmâÁ¾›¢¸ vå²¹/Kr3Íæ ¨ Õ¢i çÜÆµŒ/¾¾éÊPÌ9ÿ>[¨<«RÛ+“;/¤KÞ¹¼û81]SÚF†ôyõÞàP™Í݈ø} ß,?HR‘Ö¼îûègY7•{U‹'ptù·œPV¤Q);Ж£i¹ö¯øŽLehRÁ¹@>à[LIè-Œ¤Ybƒùõh|ž”ÿôû–‰ÄØ$@…Fó´°oàêºÑ|´]O½‰_Ò»\Ö}GåQ:ÞfN®ßGXÚgØD.þ¶›ª 4.kgÕ2O)’+7㺗oýH]‚×ß Äîær&,~è –øP~û%C.ÚãÙhC>mÆÐ§”‘# ~à|’u±TyV¥V!=Ç7ÿCtjL,±œÞò;3<ûlGéF~¨b±zÍ)ÐR*e³J—êyßãÏõ9OQêUv{ð!Ðʾhåqæû‡:”„S³ñ,^žqêÈÂQµ±ÞÉÚ¿ÿΘ¡Î¹>¿«ðiñ5“~ç³É 9m׈·zd™˜(4nø6èʨ!µPÞ?Ï¿1¿´’ÓåóÂ?®meû•‰¾þÊïl¹¢À¯ÑÓ€ϯ§:2M9zŽmÏúþCè:d}_«AQ›8î^=Çá=W¨5i&í‹>ÁøiÒ ý¶™È ¹ §ò hXÞŸ·Ô"hÊXfÕ]Ȱ¦…¹¿gãVÝŠ?¦P[|*Í¿°v{ešÕbïåKyïG\Ú·Š=•:¼‚dž VŸ€â^£ìãžëkmÜlŠQ¿º ~: Uzàç(]©Ô¸áŸ_ï^T/”_×>OéV…¦eY¼`%'Þ¡¢"„Ÿ>æHÈþ:³ò»oY’ˆ‰ŒÀ¬0‘έÛzN%q·Uð4G¯ —V0lò!’¼ÛÐØî~ÛüO¦%Ø«KÓªþ¼ýA‚ơϤH½Rœ„¿×0cñ5ŠöœÆ+…U °b™§-á$S[¿Ïåê¯ÓºqU| kIºõ¿}÷-ÇÍeéß= ¹ËØ”¥ÇG¯³vÀ$º¼ÅàNµñ¶Ü#äð~î·ú˜QsÑçò­©ðj3ÏtåýÙíxõpº¼R•âŽFÂÎb˺͜«²„ƒ¯æ¼=ìž‘6´ñ¥ÛÐ&,ºšEûû2§™5±¬À[ýª±æ“a .:ž>D\Á¿'<ò©ÉÏÄ>+pòkDrèÐ+cj}mŠR»’- ~ ‡W©W<ý ÞʾÐì–uÇAŽ™¹` ‡ žtz¯=Mªe,ÅRÑL³…ï²kí ¢T·ªÄ'9¿« 5áí@ ÿ Ãåõ·¨íú Ñ“Î~E¿iשÞ2Š%½°=æÙG0—@%ׇSþœ.Ÿç¬:åúÈt©÷h‹Q·ÓÌè<›!{òbùÝ·â¹y1ݽ*;œ —¢D±B?:Ÿ%þ»—`3p{3ŸÎúëR´-–³n}Š´›ËÓt>^8“Ö&sYš \ÌÄ©îSY±ÌS¦­À»cz±î×?X3s-÷õ€Ê…R5:0nÆpº¤f*<š}ʺEÅøô‹UL´ZŠToEÿîê\ö¹|ìGªÂ4Ÿò?ÕYÄü›Y2y €Ö;€ÀŽÓ™Ô/GT8æ¸=ž•6TâÙt0=еãëy?s­Q/JdK%»-`Yì8&,Å»‹l)R·'#?öäÓ¡§q}ä7Z=û¬.\šžVˆšU ¥Kº´ø6,¿ž€ò)—9¡µ¦/h#¬<rÈÆÞ ¿0ùô¤c7j)œ«Ñå%¶nâ¯èjÖ%’Or~W¸PãÍj¨þ ¥M·*î•P{T¤²Ó~™³•ù‘I rÅ·a_æOèŸåcEsº|Þ{‚óG…|Ñá4³&¾Ëç‘ <ªtbÚ´±4È|3”YPL_µßâLß¾} )èú!„x¡¸¸èuZ-«Ä÷»§S;Ÿç9‹f‰fï°fô9Ý_¶ C÷T’îgI,»ûÖá½ÈÙÔžB’»‹ ÂÛÛõ¯'£hâ–wß(„BXËpõæmŒFW]‡£žëƒørÎEJ÷ÿœÊ’ÈÿwY’¸wá,¡'dÊÖxªMêˆï —È ‘7ÔG.?î¹B!DþP¨ÕD^Æ„Å7ˆ1ʽøÙ¦[ѽ2nJZŸ²”Ó»¢É—*Šç–ñ:›ç,a¯{ ÞÒƒ²nI„þ¶”ew%$a+û”ÅÆª‚LÜÝ2’.îÀ½Í(fý¯$ Ç~`Æôž¼gÙÌï–I.'Û3ÝÝʇ=Ƴ³X>šÓçK™5g ½ŒkøyL5ìó´þÖ2¶}4=Æÿ۫Øù?ìîæ‡Ï¿apVm™@ @éI“1sðˆ0¦[73_g镚´(o—³òòHÂÉùŒÿ6„jã¾æËÊ®ØöÅ6ûÕ¬cºÏ®Iè·NOí®˜TÉSØEN^#>]RkU»>çq¶šU13}åæ2/ñö:Š8¹ó÷&–~ÿ¯iض -^ªœì£•åYÛ¬úUl”§ÏÔ~ø§u25î•Ý3ŒPåkŸBˆg„uɼmQê¶lC`–oHZ*ZËæ<­–øOP£óÒ½|PÜõAG{½E»6gÊŠÕœïñ?*Ù=®€†K¬³ƒ¿Ù0ýJª¦u)ñ ½~Å‘N_蔓í鹸úK~¯É' 'ÐÑGÔ§l\kÚ};›?ú,§­§2ïêoµ8þÚEœ÷[¬ø¬JÙ¨í~FïocSè(jTÕ‚BKÉ-)™~ÕØƒìšlÁ¾agj¹(rV^Iºs‘peÚ¿ÙˆêNyV,q'f3n] /ÏÚÂÜ6^¨²\ÊÊv}Îãl-ëbf‹î½|“þ¥7_§®M :}·Š#­s3k˳:¶Yõ+3aê´hC#ÇGÇ ?û¤B<+”EÝždLÝši5nîüŠ÷_«G]ÅFtùßZÎe¾Œ+þ[”IŸ¨ Q¥jaˆºAdúA9 ÜÚ5ŸÁí©¤Ó¡ó¯AÓ.cXsI%î"‡®@ñfø¤¦p" Eelb°%$!gÛ3ÞbßïW¡rGšx¥¦8Z|[¿Jãq6ŸŽÍaýMD]ÆØ^­hPåÁtœ ëÏ“±‹gwX°Ø¹¢M˼Ø8;cƒµRÁ£DÿÄÎh'št®sÚb9)ÏšcôQmΟoûSgÈ_`>È€š:tº@¦œL|l»¦±Äs~ÝX:Ô¯€NW]&ñóåDl9†ßm"¬H5÷B…sV§kÛµ€ãüøxXy®Ì«˜eIƒ«·sÊžåf­)ïaÇ6æ1ý*¥Vf‰I¦,ÊÍ~]!„ø¯PÔ.ý˜¡ ‹¸èh¢Ó~bH°z>¼™û;ÇÓ±ÿ<ΖêÁÔ…KY8±5ª-ãé6r3wd^ý‹ÅÆÉãw H%Ф]ï6¶ã#Ú÷›Ë Ï7?ïk–ÌKWÿ$®FÁdÀ¨mÔ¤O”[TDrþR4œ>œÕöô·8u <ýJá˜îš¼OEŠ çêùp Yö¨ú›‰¾zMõî|8s ˾ùŠ1­´ì׋Iû¢R kŽ'jôh‰ë¿+˜µú7£ãˆ¸ô' ¦o#Þ¿+u¸ `‰æøšÝÄ:7¡SÕôÃÖ–gMÝ×FvÔÿ|Æ€¢:S~ÞÁŽ?Ö3Ø_ýøvMuf>#–%Ðr–ÎAÝðÕŒî9…Ñ))šþG‚ãÑúúð÷ÔŽÔÕùáïWÀ.ùñBƒDÎêv-¨8gÓÏsr®Ì«˜¥1‘”O\t—|Ïg_‡âÖú껥2§1Ë®ëÄÏ®4íglᵱ׸|Û€sñRØN“¯KðªŸs†u²Û6>Tô_ÏýK¬¹Ú” Dë7±E§óÈ0Å&»ò,±á‘:³f2¢µGJ]⸧p³UÇþ§oAáfåqMwPدF •‰«Â0â™áq˜æð¬9lÀ»g;t™÷S˪ò¬©›M¬m”‰Uí s—3x§]ª‰án Ø•qB£ ¹½Š)à¶9ÓU¼ä›:©7_ZÛ®VÆ%ÏãœM<¬;W&æm̲¤Ä¹|e¼9Àåp`—«˜=¶¼tÛ°˜Œ˜Q`õ§M!„øÈ÷o€UªEÓ&θk_|}Óÿ”¡˜s¾žÈu„Ï{ÀFËÌY>œÚÎw9•gMš”°p|åvndy>•k Êû•Å[ý/æí ! +¯•~z[³=Ô>6/'×òçíÔ1ÜB7o妺­+:æ¨<‹) ½Eƒ£³mZa‰ æ×£ñöÑšã@íJqW¸óÏî§ZNø÷ÿšÀ½¸k¦¾&îíYÃ_¦"´y½EZYž5u³¾°z+¿ñçÕ·nüÉ–K ü•IÞ'¥5ÚÀͽì¿õ  „?9§¢lÍâÉãÕÖ¶kAÅ9›xäè\™W1Ü2'=·îå*…ÑyÙä0fV–gml³dƘy^•é6;WÅ`££VQ¹ÉUñbÉÿLÚ¦=Ƕg}ÿ!t2€¾¯Õ ¨Mw¯žãðž+Ôš4“öEelþ?ÉxuCú²ì‚ ׯpdëƒï#Тz“:ÉO„±)K^gí€Itx‹Ájãm¹GÈáýÜoõ1£ªk‰>ø·ÚSÉ¿úëݸ‚M¡þ ]ß%ù¹ó9Ù6”í6Œ—¿Æä~Hì×çâ‹¥7)Þû ^òTæ¨<¥[š–Idñ‚•œx‡ŠŠ~út ›"!mƒUÇŽŽÊñý¼‰¼ûá}ÞkY»°c¬³œ›/1ªI¡ŒI¦é»‚Ža.>€×}³H`ì¬,ϪºeßFɶ]S–S…±lЇ¨†µÇŸólü|&ç=Û³´eê} *жE—%½˜Ùw¦ZSZе_|Çí"Ý™ÙÔ#eTÂÊvµ6.yçìâaM;äqÌÏ2»×.øRµLQÍF«Õ¦%å©£øZ­“É„Z­&!!ÈÈHœœœÒæß«Õê´'á( ôz2 >¬ IDAT=*Uò·'§ŽôË °"7”Ù/"„BñbÐëõ888 T*Q(Æ´[ ...iO²I½6)) ‹Å‚­­-GGGÜÝÝIHH &&†ÿ³wßqvÔUãÇ?Óçöm©yÑ\é-! ª(ŇPª@  (ÒžP䇣*å'ø&(EH|%„l»uîÜi¿?6óeBȆ$Kä¼_¯}±{ïÌìÌî=÷Üó=' Câ8&“É`š¦Z ›v·Ñu]eë…. æ…B! Ã@ðiÀ `Û¶êZÓjµÃZ­¦²î¶mS©TÃPeÞ£(" C ÃP-,Ã0$ŸÏ300€mÛªn¾P(Œä¥‹µÔŠóQ?ÏÞ>ƒ£öÚžM»»éîÞ†)SOãG|f2tÃ:v3º¼‹EñòØà‰ooG÷WnáõèCœý^ÿýõ\ó‹ç¨,÷{‹‘Ö|q»tïÎ絆±—ü~…B¬éBÕ °m[•Êäóy¤§uòC‡HÕëuÚÚÚÔþº®ÓÕÕ…ã8‹EUoàº.¥R‰0 ñâ£O~¿B!V?Ã0(—Ëd2ªÕ*I’`š¦•vµiµZª_¼ã8ÄqL£ÑPõïC³ñµZ ÇqÈçóT«U‚  R©¨¬|Úo^ˆáú€°oÿæ¾sw/Ûœùk~zôƸ‹Ÿùâ¾û²ãY{sò§ð£ïæôÍÜåiI¶<ãîYÙ³B!„X LÓ$—Ë©Zöt0T6›¥R©$‰šâšÏçU÷›V«¥Jm,ËÂó<\×Åó<>ñ‰OP¯×U§›l6KE U—_*•TÖ^ˆáX~f>˜Ïon| ü‘L?ìÝ@cŸ;ã &óùÅÍϰÄ̲¤ÁÜ_žÃ;nJw÷¦L>x¿ùw“wªË*³ xë¡k8iïKy6ÿ,Ÿw/ׇ¦a<|ÓöÛ‰-º»éÞd;¦|6¿xu€'¾ýY¾qŸ/]Ä”M»éîîf×hÿ¡~<âC‹Ë¥ýãã8V‹fã8ƶí%jã-˶m5ý5“É ë:ÕjUÿÌ‹•±ÜÌ|R~‡_ΩŸgƒe$Þ®Ïðånxú™G™ïïȦÎâ'þq§Ý¼ÇžÿßœªÍeΗqæ]¿»˜ÉEmß)¦ï¡éxÜÜ=§qé©[Qì}”›fMçÐÞ ¿¿ö+Œ1"züûŸx7Æ.ßdúµ“/bîã0¿ßâ«Óïà²òW9ó­c¹íú}£kX¥1ÈV#)ä_žÌ‘—ÿM¿v?Þu4}¾‘‹ÎšKmC¶‹©ÌkÛÃ8ë°uèÌø¼þøl®>÷H¼1÷qÙÎE¶~ßßoÌÛËݷIJî8!„bYâ8&Žc’$!IUúR«Õ( „aˆeYÔëuâ8&›Íªö”€ªµ:t ûÖ›¦I6›U bÓ7–eáû>¾/)H1|Ë æÃ×é:7è\vPl”Xwœ ÿ~þHƒù¨“oüè2ŽÙÐvbûî„îyWÿá$>sÐ8Œ¥Óz…ÛfÍa`ÒL¸ò Æ“™8®—Ï} w¼úNžð*·~÷n¶½€û~t(ë.>ó]öÜñAÆ2*§ƒÓÁøuÖ]| 1¢š/sËuO`~î~ô=èÔ¶¡óíÝ9î÷C7´˜°ÿù\8ô¡wd½·§pÂOŸ¢²Óî”Úßÿ÷ûûJ4/„b¥ W5mðGÚ#>íL£iÍfSeèÓú´ö=]Ûh4–Ø'$†!Œ3†þóŸj‚lº¿õzZSNø"Ÿ[ïÝ¥­Ö'vc¯ ^þÓ+4—±yÔóWz ¶œºãT¦QÜê‹leÏç±—+„=Oó§×5¶9lOÖ‘{}­õ<Ë“ M¶Ýï3ƒ<€ÞÆÄý&±ô=qå9n¿àë|q‡-éî{;¾qOïÍyô,]•³ ÷B!†Êçójˆ“eY*ƒnš&a⺮j/E­VK-–­×ëd2Êå2I’àû¾*«qGÕÑW*æÎ«ŽDZêU/Äp-7,6ÛÖ¥xíÕ^Z¬Gfé ¢2¯/hBûÚ‡©0šÂЗ FÑhöW Xºî!ª-¤ ¼xúd>uú{Ïã“} ‚Z5²¬ß•‘²‰µDÔè¥NÍÚ—ìYdµ§È?‡l¸€9ÓgÆK9öŒ«™ù©±”܈Ýp §>ã.ïß¶³¯B±” 0M×uU@ÞÖÖ¦>Ãz½N©TRÙ{MÓ¨×ëjØÔÐ?]ô:00@GG¦iÒl6©T*”J%êõºz!5óbe,7˜×J›±ë†ðƒ??È«ÍmXºaMÔó8÷Î…Â'³ž3ä‰ê;Tc›fÙ£*ïTÁÝ €µŒHÜÈu’Ã`âŒÛ¹pRn©guÜÑã°k£(Ð`QGBVúµ€‘í$G“²·ä0ØÀòuÒÿ4w=²ý÷/ç´/u.þÝÖYÔZÖû8Kú0û !„K‹¢ß÷Éf³$I‚ëºÔj54MÃu]|ß§P(¨‰¯qÚ¾R©àº.QÑh4Èf³8Žƒa¸®»Ä‹…žž¢(¢½½F£¡V 1Ë/³±&°÷1;`¿õSfþüŸK–ÈD‹øãå—óT´‡µ-ù¡Ï½öþ8ÿÝW—Á›äw¯j|ê³¼§¼À5‰)ëE¼üØÛ´m°m4ôcÖ)š]Ùu½„gn»Ÿ7—y¯k˜¶GK²± F×Ö|zŒÇsýkHðÞäßz†êí’ȧ•X䋎z‘–Ô^äÞ§C¶ZöïwÅöB!VŒïûd2âxpB¡aj8Tºø5Í 'I¢JoÒÞñ†a¨n7™L†b±¨²õ¾ï«ÚùÑ£GS((‹´Z-†úžB ÇTŸŒÛ{³;ˆÓ¾·/ûýýhÝíS”üù<ùëŸpÇ_›lwÚM¿éR!ºÑÃÍ'ž…ñ­ýÙ„¹Ì¹ârævíÏM_ûÞůöÆqÎþÜyÜ)rÊñ»÷v|®óÎü—yâÿ½Æ¤—³ÿ'6äðïìÃÇÏà0í O36Yļ'¥o¯‹8c[‡q[އ{~Ë÷oÉç?‘!;f#>9VÊrFŒ» _;~³gžÃ÷?óc¾5e4}ÿï*Îýù[Àºj3½}+¦lÐä†ÝƳ›ÅæÚ<~}ÉÙÜ=ïÖv½Ïï·cEöB!VLlGQ„®ëj+ ïžç©…­Íf“8Ži6›d2µx6}>í;ßl6ioo§T*© ~†ê9ÇqÃPÀŠ•òÁ `Íq|ù{¿áÈØy¿àÒ3¿ÅéÓ¯çÏádNùñ=Ü|ì¦d—Ž–7=‘ïiqïùGsÔ´Ëy¬ý fýl:“Kï÷ít:¦\į~z:[¿3‡KO:š£¾y—þäÏÔ6Ú‰ÍÛtÀ s·Køåõ'²å‚;¸àÄ£9æ¤ ù?/Ú¬×nŸØ÷|Nù¬ÇÏ¿utÿuË«´>äH|&ët-7º>ž¹Ûn6‘Cn¨sÐŒ©Œº™½G]{ _jÞÄÁ;lÎæS¦qOÇÉ\6uìÞç÷»Bû !„+Î0 5ÌÉq\×%—Ë©¾ó0ØjÒ²,Õ¾Ñh¼§½d.—£Z­â8™L†R©Ä:ë¬C©TRûµZ-õAjæÅÊX±—€FÛ:ƒ›ñæÙå^dîâ¯v:ä{ï³]D£Ò'£^˜ŒÚá.ßá˜åßbü”i\7eÚ2ŸÕ‹ÛqÂ?À p–b 2Ú˜ôÍëøý7—|øÐ}‡~¥‘ÙðfÍ9€YKlõUu/Ár~¿+°¯B±"Ò®3Q©÷0 Éd2hšF&“QÏÕj5LÓDÓ4t]§­mp†J†hš¦»:ŽC[[ßÿþ÷Ñ4K.¹„ñãÇóÒK/Q(¨ÕjªÝ¥õÆßωk¯ñ÷ÇÏ- s@7ÅÕÓS!„bؾïÓ××§SI‰XYküÎi¾ðCŽ=ñ>ÜOËwÛd™ b…B!F‚aªä%­cO’˲ˆ¢HM†T-= ÖÚ§½çÓíÇ¡Ñh0jÔ(êõ:?ü0Fƒb±H__¥R‰žž:;;yã7pçýNKˆ÷µÆƒùìg®äi©B!ÄGP&“!I4M£Z­R*•€Áůù|ß÷UYM:6­}O;Öärƒm¶[­¶mÓ××G³ÙÄ4MZ­– økµ¹\Ž… 2jÔ(úûûGòÒÅZJŠ\„B!«V«T«U à —Ë©Ý4MÕ>Šç§ø¾¯¦Å𦉮ëäóyšÍ&š¦±Áà8Ž*ÇIƒ{ß÷ I5`jÁ‚Rj#VŠÜ5bµ˜={öHŸ‚B1l®ëbYF]×Uy¦i*øN·iµZª}ªN±X$^{í5Õ'] «iÙlÛ¶)—Ë$IB.—#“É`Ëlà-ÄrI0/V‹éÓ§ô)!„ÃfÛ6´··Ójµ0MÃ0h6Gg¦=èÓºø$IÔ0¨jµŠ®ëxž§:Ó˜¦I¡P```€ T7œ´…e>ŸÇóŽc•qÏf³˜¦ÉÀÀ†aຮ*­ñ}ŸL&C†´Z-U~êf“ÖÒ7 2™ ===4›M\×U--³Ù,õz}¤/_¬…$˜«…w³gÏ–oBˆÿ(ißø8ŽI’Dõ•×uÇqð}_•ßø¾OèºN&“A×õ%²ëi ßl6‰¢H ˆÒuQ£Fáû>I’¨~öù|~¯\¬­$˜B!„XÌ÷}U oš¦êTI’`¶mÓl6ÉçóA€a$I¢±Æq¬ÿtk£Ñ u¬z½N«Õ"›ÍªV—R3/V†óB!„‹%I¢¦¾¦m#=Ï#Š"•µ‚@-bÍf³T*ŠÅ"š¦©ÇÓ.8AE‘ª·, ×uÕ14MÃu]ÆÈ\´X«½Ÿùèæ¶)ÝŸ»’¹­emPçɳ·§{ëùc9YoÕà‰ooG÷WnáuYß!„Bˆ Û¶U eYÄq¬O[R¦%8Q‘ÍféïïWýãÓ…¯¶m«AS®ë’ÏçUKJ€r¹Œëºd³Y ÃPõùB ×ûóF;<㻹ûÿ½ÏןçÎÿ;@î³S™XÔÞû¼B!ÄZ&Žcâ8^"ŸfØ}ß§Ñh¨¶”®ëÇ1Åb‘l6K.—Sü´ÛeYø¾¯O³üé4ØjµŠ¦iªtGˆáZÎXŽæ3Ö›Ü{÷¿X:œ¯ýý—O†X–¥‚þ(аmÏó¨×ë2V¬”åó w|†©ŸqxëÞßò¯%^,VùÛ/¦RÜ•·.ýOÝÌ9GîÅä­ºéîîfë)‡rþs©¿_N¼ˆ»ìfËã¡6äáæs3Ù©{®ûW0äÑ€·º†“öÞM»»éÞü³|Þ¼ü¾B!„>Û¶UëÈööv‚  Ùl’$ mmm* O3ø¦ibY–ji†¡šòšN…MKuÒ:ü´L Õj©ôé;B Çò_jílðޏ'þŽ9ó¾Åf[.ÖH*ÏrÇŸj´íy[åb*óßÀÚö0Î:l:3>¯?>›«Ï=oÌ}\¶s‰•OÞÇô=4›ƒ»ç4.=u+нrÓ¬éÚ›á÷×~…12ýX!„«@«ÕÂqªÕ*™L†V«E¡P \.£i™L†l6‹çy$I‚mÛôööÒÕÕ¥‚|Ïóp]Ã0ÈçóT«U|ß' C†a¨^ô®ëªÌ¾Ãõïçh”>=•3Çñ‡9/sÚ–[“!¡úÌü¹ÞÁ—Ø‚,ö?Ÿ ‡îºóެ÷öNøéSTvÚÒÊFó­W¸mÖ&Íä+b¼0™‰ãzùüÑ×pÇ«_àä­•<¸B!Ä»¢(¢ÕjaÛ6¶m†!ŽãP©TTËÊjµJEªtF×uººº0 ƒF£A6›U dÓc¦½åûúúÔ)@M”( #vÝbíµÜ2­°S?›cÑýsxÙ’ OÏ~„Fמì¿iFmWžãö ¾ÎwØ’îînº»·ã÷TðÞœGχh›õü•‡^ƒ-§îÆ8•×(nõE¶²çóØË¤ØF!„«B’$¸®«zÌhš¦zÉÆ`0R*•( äóyU^“ÖÄ'I¢¶MËi4M£Z­ª Þ²,u¬ôyÏóÖðÕŠÿ¼ÒB+²õÔ)»þq6[oøw<æ1úÀýØ$å£Ì™v83^šÈ±g\ÍÌO¥äFüë†c8õŸðCDÛQm!UàÅÓ'ó©Óßûü'ûÄt"•6B!„ø°Ò¶”0`×j5ºººÔt× ÈårT«UšÍ&®ëªÒÓ4Éf³jXT¹\¦½½0 ñ}_•ݤÙü´ýe³ÙT‹b…®Z6]Øú@v+ÞÃw=Ïq»Ìæ±æ8ýj7îâç“þ§¹ëñí¿9§}©sq}|E­å´XÒ4,’$^âá$ðšÈ7rä0˜8ãv.œ”[ê :îèqÈ !„b•hµZX–¥:ÍX–…çyär9Â0¤Ùl†!¹\NÕÓg2â8Vi<Ïöm2™Œšú ï–ð¤A}ȧÝqÒARB ÇŠõ@ÊmÉŸoç7ü77¾ú8þø#Ùg#G=D>­Ä¢­è¨…®IíEî}ª™e-C×è,­ù¯S‰ o,xúoôÙÌ5‰)ëEüì±·i›º']X$„B±rt]WfÂ0$“ɨ’Û¶UûÉ8Ž ÃP-dµ,k‰N7€•fúÓ•iNÚ_~h?z!†kCã,[°•?sû³ëî³7¾Ë£·oÅ” š<ò£Ûx¶/ è‘;gœÍÝË?æ¦ûîDî¥ëùá½óè­ô0ïWpÖÿ»äföÆqÎþdï?…CN¹Š;x„Gÿtsn½Š³ý6w½)oI !„bÕpGÕÁkšÆÀÀqS«Õèéé¡X,ª…±i¹ @³ÙD×u°mMÓhµZ$I‚®ë˜¦©Êv`°œ§V«áyÞ™{!†k…óÜ™MöcÏQØ÷K°ÄÀa{#Žºö¾Ô¼‰ƒw؜ͧL㞎“¹lêØåQ£m—\sÂÆj,³5<2— –ù¤FfØ5çf-ñøW™«>ϲýþ:äkÀèdò)7óÐ)KmŸ½Þ{š£v8†Ëw8f…OW!„beضM„aˆëº4›Mâ8FÓ4ŠÅ"žç‘Édèëëò¬%jߣ(¢T*ƒm']×%Žct]WÝn¢(R gÓůq3jÔ¨83!ÞK^ !„B,æ8abÛ¶šêj¦i¢ë:õz$Iˆã˜b± 2꺮«Q–e©v”º®S­VUé @¹\Æó!„bØÒ@>Õ*Òq4M£^¯c†òdÙl–F£¡@eÛÓî6é ¨z½Ž¦iX–E¡PPå8…BAÕâ 1\Ì‹Õbúôé#} B!İEQ„ã8躾Ä0§´ý¤çyttt¨~òq«Å®é"Y˲TùMET*UV“fãËå2Fƒf³‰ã8Ë;5!–I‚y±ÊÍœ9s¤OA¬aS§N]eÇ’wu>žVå=$ć‘ãKOM;Î8ŽC˜¦©zÏGQDEtttÐjµT>“ɨQq«AT–e©6–¹\ß÷q]W-ˆb8$˜«œdå?~æÍ›·J'÷ÐÇϪ¾‡„XYÙl–8ŽÁE¯i^«ÕÈf³èºNEd2Œ§‹[mÛfáÂ…är9t]GÓ4t]Ƕm5<*]PEš¦áyÍfS½8b¸$˜«…üaþx˜={öj ¼åúxX÷+# ä™LFu¨ Ãp‰À\×uµÖ4M‚ `áÂ…d2Z­–Zkš&š¦aº®ãû>ù|ž(ŠT`ßÖÖF¿”Ùˆ•"Á¼B!Äb¦iÒh4èèèP“]ÓáNiI¦iضM½^'ŽcLÓ¤­­ ß÷q‡f³I6›USaË岪­w‡¾¾>ÚÛÛq‡jµªÎ.Z´h„¯^¬dh”B!Ämmm$I‚aÄq¬ÚF6›M`0à¢Ó4U–}``€f³©ZY¦_W«U²Ù,ù|ß÷Uð_©TÐu8ޱm›L&C6›á+k# æ…B!«ÕjjÂkú9€mÛj᪦iÄq¬¶µm]שV«ÀàBÚtòk£Ñ CÕ%ÇqœÅí-›ìò½¼üò\^zéeþýïÿ©Ëk1)³B!„X¬££Cu—©ÕjŒ5Š… ÒÙÙ‰çyDQD4›M2™ a¢i¾ïcÛ6ù|žf³I¡P ÙlªmÓ,ºÐup;r3†ÄåÚÓ\^I::Fú' Ö6’™B!„X¬ÕjEõz]ä¶mE‘ ÜÇ¡­­8Ž ‚@-†M»f³YÞ~ûmÇ!“ÉÐÕÕ¥ÍA Ôf2.9[ßà¹G?Átô勵óB!„‹5›MÂ0Ä÷}¢("ŽcòùYéËk! æ…B!ì2“!IÇÁ4Mõ™L†B¡@½^' CJ¥¦iªì|Ú—À0 UšÓl6±,‹þþ~2™ ¾ïS«ÕIˆi=F•ð1r×!„B,–fßÓ€=5´å‚ Ô°¨$IhµZ*àã˜(ŠT÷š(ŠTéM?ÙlÛ¶Éf³d2.I Sí,ãb¸dh”B!Äbº®“Íf©T*tuu¡ižç©ùF£A{{;†a¨’Ó4Õ¾š¦aY™L†|>O¥RQ}&“Á4Mjµº®cš&–8;ïíSèoŒìÅ‹µ’dæ…B!KÛOf³Yâ8V¸eYÄqŒëºÔëu|ß§^¯ãy¶mÇ1¹\Ó4q‡$I¨V«d³YZ­ض­‚úTœZ“#Ïÿ7W^¹pä.\¬µ$3/„B±X:ŵ\.cÛ6…BÓ4I’MÓèìì$Õݦ··—R©„ïû˜¦I£ÑP h+• *ð/‹hš†mÛø¾Ïük'òé«"ÕŸ~¯½Fø Ö:’™B!„X,“ÉEmmmhš†ã8†¡²ì†aP¯×Õã­V‹|>O«ÕR‹aã8ëì=Ï£\.ãû>ù|ž\.§&Åvuu©¾óÙ5UÎ IDATl×uGøêÅÚH‚y!„BˆÅÒŒz:8 PYxÏó0MS•â躎mÛT*4M#ŽcµèU×uÂ0dÔ¨QÀàdÙ´»ëºtvv’ÏçUßútÒ¬Ã%e6B!„‹½ýöÛtttP©TÈårT*ÚÛÛq‡ 0 ×u‰¢H „êììÄ0Œ%2ù–e1zôhõB Ü}ßDz,jµš âóù<¥R ÏóFúòÅZH‚y!„BˆÅ …0Ø#~``€R©DÇÔj5òù<===ª§¼aj’kZ†“.„M’„ Ô¢W×uÕô×öövt]§^¯cš&årY-´b¸$˜«ÅìÙ³GúÄZNî!!ÄHHï\.GÇ4›MLÓTú¨Q£¨×븮«úÌÇq¬ZZzžG¥RQu÷}}}†aäóy²Ù¬š›n—§j6›#}ùb-$Á¼X-¦OŸ>Ò§ Örr !FB.—£¿¿Ÿ8ŽU;ÉF£AEªŸ|6›U¤Ò–•I’ÐÛÛ‹mÛªãMÇ´··S«Õ0 ƒL&ƒ¦iªþ>›ÍÒßßaA `ÅJ‘`^¬r3gÎéSkØÔ©SWéñäúøYÕ÷+K×ut·Z-\×¥ÑhÍfU¿ù T¦>Žc|ßGÓ4\×%ŸÏÓh4ˆã˜|>O³Ù¤££Ã0ˆã˜F£¡¾OÚ§V«ðU‹µ™ób•“ŒêÇϼyóVéñäúøYÕ÷++]°jI’¨€>Š"Ðg³Y¢(¢T*Ñ×ׇ®ëär9¢(RÝjÇQ d[­–ªŸïëëöm<Ï#“Ɇ!Žã¨ì½Ã%Á¼X-äóÇÃìÙ³W[à-÷ÐÇÃ꼇„X­V Ó4iµZX– ïb±H¹\&—ËÑÛÛK±X¤Ñh¨òxwð –ähšF__ŸDÇ1Åbß÷ ÃPµºL³öB ‡ô™B!„X,,ËBÓ4²Ù,¾ïcµZ0 UfÞó<Ç¡··—l6ËÀÀq£išêOïyõz¾¾>:::p]Û¶U|ºpV×u‚ P/„ÉÌ !„B,–$ –eaš&žçDZZÈE–eQ¯×‰ãXeà†ê¯ë:–eaº®«Ré`)@ý7“É`Û6®ëR.—GìºÅÚë2óMž¿xgº»»‡|lËîG\Àì« Î)«ñ§c7£ûÀ»X´Ú—5xâÛÛÑý•[x=ú(s-ü››÷ß„î=®à…%æWD,úÝñlÛ½=§?ÜÌ©ï+|ÛÛŒî)—ðL=Yò¹è-îúÆ–tïrOÕ’eï/„#$­_¯V«†A.—CÓ4ªÕ*AP.—ÑuMÓ(•Jªž T*‘Édp‡þþþ%úϧm,mÛÆ²,&L˜@©T²,¢(RÝn„®+³Ñ7ã„+®ãºk¯æ²s¾Êè—~Áù‡Î½ï¬éèW#3nC6žÐ†µ†¿óÇŠµ>‡Î<Ž ^»‘óný­ÅÇpÙ…$™23wn—-ñþÌuÙÿÂSÙtÁÏ8÷Æ—y·srDσ³¸ô±,ûÌœÆvyyKYñÑžç©>ò¾ï«Å«õzÃ0ð<]×yýõ×1MÇqèéé¡Z­¢ë:µZ$IÔDØt]×1M]×yë­· Z­R,%˜+mÅâ1{Ûí¶;»~Oö9ò–—®º€»Þ!©ñ׫¦óÛÚDÎ<ï Œ–Ÿ¿øöF‡sñqëóêõçrÛ«Iå/üàÂûI>wgLn“„Bˆœ8ŽÉf³´Z-,ËÂ÷}lÛVƒ¤|ßWÝlÒ2MÓ?~<0X¦“>–ÖÓ§/‚  §§Çqp]—l6K>Ÿ' CªÕªZ@+Äp¬ÄßRÜÆÛ3è{­w¼qÿ,ŽØu º»»™´Ï™Ìþ§Çàm³è·G²ù&ñ‹·– ÿ›/Ìb—îí9û‰:SyîVÎ<`'¶X\Ö³õN{sâMóðe—Ä,xø:¦í·xŸM¶cÊÁgó‹W[@DÿS7sΑ{1y«ÅÇ›r(çß9—¥ßùKÑòlsòEìSxšïÍü=¯=wçþ|!›œr!û¯#K-ĊȰé1—pĘùá¿âͰÎß®Î]µíùÎy{0J^ !>‚:;;‰¢Hu—ÉçóضM¥RQí&ëõºê+_¯×)—ËÔj5UOßÑÑAÇ Êå2…BA-œ¨×ëªÜfhŸ>/Äp¬TTöþ/½@®3ú{üòõœzÍ–xò|Íø¿ºüjÎ?i¶¹{Ÿ´uº>{$»¸ÇsÛïßà€£',þÆ ^¸ý·¼=æ+ºeêOòÝo^̃Ãù?Þ‰õìoýó¯;¢çÁï°ÿ‰wcìòM¦_;‰1ñ"æ>þóûC@£2ÿ ¬mã¬ÃÖ¡3ãóúã³¹úÜ#ñÆÜÇe;—7ùߟÞ6™3Îß¿u‡<Ñ;á›ÜuÄFØ#}bb­¡å·áä‹÷ãÞ£¿Ëô«_ä­[²ÅÙ7³ïx‰ä…MÕj•|>¯¹A@†jѪã8ª•d³Ù¤³³“V«E?¦iR*•ToúZ­F&“Á²,Â0Ä÷}ººº(—ËX–E³ÙT­0s¹º.ïWŠá[±`> i64ˆh¼õ?;ÿ'¼ÁœüÙq˜iEu8–ãþûJù„ìÁöm/±Ëý‡ßï¼ó…B Ôp¨jµJÇ8ŽC½^'Š"LÓÄ÷}LÓ¤^¯Ól6q]—V«E&“Á0 Þyçòù¼êœE‹-éËk¡{ è?̉;mÃ6ÛNdò—ç†Ç󕋯嘇äh7ú";©Bvì„-Ëo ‹˱աû0öµ_qÇÜ&Ðÿ—ŸñÇê'™ºï؀ٹ)›—z¸óü\ÿÛG™»¨¹ÜŽ)QÏÓüéumÛ“÷«üˆ+Ïqû_ç‹;l¹¸Ïv|ãž Þ›óè —½H%Ô_˜Í¯^àٿ̲Qˆdt±ëq2˜xÒát»#}BBñþÊå2F]׉㘠Ðh4T'šZ­Fªõ$ žK?‚€ Èd2ª¾ËhÒ––¥RIí×l6©ÕjêB ÇŠóÆ6œñß·rë­·1û×ðÄßþÀnÈ“Ý<îÐ,·nb‰ÆÝOÄAë¿Í=·?O#ZÄÿû?ÒÚê0öJ#ñÜ$Îûé%Ôù,7œq{ï´“ö>[þ^YfPÕz¨‘etWfÙå2ÑæL;œÐùÜiWsÛ]¿áž{Å÷î€À'”ºùåk¾ÌçÝÊÛ›œÈåߘÀk7Nç¶WZ¼ŸKÑ, Ó1¥´Mñ‘æyžª•7M“öövÂ0$Žc à ›Í’Ëåˆã˜$I0 ƒ(ЍT*A@«ÕBÓ45@Êó<2™ ýýý´Z-|ßÇq<Ï£¿¿ß÷iµZj‘­õbe6V'Ÿšøi>ûßÍZŸ}ÛŒk¯ºÇŸÈ­OilùîC:Óèä79€órÓƒ~^yòÜ2k&——aó?^ÌvK•xùQh°¨Ç#!ûž !éš»Ùþû—sÚ—:?_gQKòË,àoŸÎ ¯LàØ»ŽåË>Ã3÷ÁUþš½~rRò,„â?‘eYA€ïûhšF†ttt000°ÄVì|†!–e©:zMÓ0 C-–5MÓ41 C}Ýjµh4d2’$Áq àZ­Žä¥‹µÔ^ia0nϯ1Ñ€ï^øc^p?Ë×vî\æIhV;M>„3N™„Þ7—ÿ­¾77otMd×õž¹í~Þ\FÉLù´‹|ÑQ~R{‘{Ÿj¬Ò«úO½õ[f\ù<_Ì77Ë &2í½pŸø³ìYÃ-I…Bˆ5#-¯ÁÅ®ŽãÐjµTW› 0M˲TÉŒmÛKüWÓ4t]Ç÷}°GQ¤ÊhÒ…³i?{MÓˆ¢ˆ\îÃfMÅÇÑ_6mŒÚ•¯ïdñÚßz(íñ5>Ýön>Ýé¾þµ³¸úçwóÇGŸäÑû~Ê¥?x’xýÙ¢m§joÈáßÙ‡ögfpÈ ?à—>Ÿ˜ÃMŸÎåÏ4ÐÛ·bÊMùÑm<Ûô¿È3Îæî5xÁk£¸‡ÿûÝYüÅÙ‹§L¤ ètìr&çìrÿEWòDEj”„BügŠã]×ÑuÛ¶Éårª¤& îÓN4I’ÐÛÛ«ÊlÅb˲¨Õjxž§>OÈ `۶ꔓNœb¸Ö|$­Äv_݃Q|ùЭÈyÊìÜœ- ¯òÛ«Îåø£Žà¨oý˜ç×;–ën:ŽO.sMˆAçn—ðËëOdËwpÁ‰GsÌIò^´Y¯Ý{#Žºö¾Ô¼‰ƒw؜ͧL㞎“¹lêØ5t±k£„ÊãWrá};{»v ¹EŒq|ùüo±eÿœÃóx#w’B!ÄjÙl]× ÃÛ¶‰¢ˆ xçwèëëSYú8Ž P(P(T½¼¦iªLDz,lÛ¦X,ÒÑÑ¡&À:ŽƒmÛhšFäóy%VÊÔÌ»lqÞŸ™{Þò¶É³Ëÿ¼ÈÜ¥<áhî™{ô{7Oª<ÿ»ç‰Ö=Œ©›.YoŒžÂ·¯›Â·ß÷{eÙþ]ê{YŒŸ2ë¦L[æ™ `Öœ˜µÄ£_rŒeóãL£¸ã%<:÷’e>kMø:¿üÇ××ì)‰µžýÉSypî©#}Bñt]GÓ4ŠÅ"===èºN½^Dz,J¥FÏóT>I’$! ë}Ó6•žç‘Ëå0 ƒV«Eôõõ1vìXšÍ¦Êð—ËeÇÁ4MñYôÏ¿ñد®`æïlsôl$˜„Bñ’$ ]]]¼þú몋M:¶^¯“$‰ÊÀÛ¶M>ŸG×uLs0?jY†a¨é®årß÷I’„qãÆQ.—‰¢ˆÞÞ^t]'›ÍR,yûí·GøÊÅÚj¥&À®”`>¿8q*×¾f3á 0k¿uÊ0!„B|”X–ÅÂ… ±, ˲TОçÙlÇqð}Ã0TëÉt¡kÚáFÓ4Z­ÖC¨4MSå5¶m£ë:™L† 3fŒÔÌ‹•²æ‚y{cN¾.'¯±o(„B1<éB×t°S³ÙTA}ôôôð /°ýöÛãû>ÙlÛ¶i4ÄqŒçyj ÔÀÀš¦áº.Žã ëº(¥ë:µZ Ó4©T*är9•Ýb8ÖüX!„Bˆ¨tÑj>Ÿ§··—Z­FÇÄqŒëºttt°ÕV[`Û6­Öà0Åtñªëºxž‡®ë‹E5TÊq*• –e©6•mmm*;Ÿ–î1\òP¬³gÏéSk9¹‡„#Á²,LÓ$ ཽr¹¬:Ïxž‡¦i”Ëe²Ù¬2庮Z̪ë: .Ä0 òùŸÇó<Õ²Òqjz¬ïûª'í+ïû>¦iª¬ýøñãéìì ÕjQ,GìºÅÚK‚y±ÊIFõãgÞ¼y«ôxr}ü¬ê{Hˆ••Ö¾7 òùÁÑ–™LF•Æ‹E5LJ×uFM__ŸÊІ¡ÚY¦ýãMÓÄu]µ ¶­­0 Y¸p¡PÕl6±méÙ-†O‚y±ZÈæ‡Ù³g¯¶À[Õy ±2²Ù,QÐÛÛK©TRí)Ó,}Ú¢RÓ4Þ|óM’$¡³³“f³‰¦iÔëuLÓ\¢^¾Ñh¨AQiÇœ´Me³ÙÄ0 &Ož<ÂW/ÖF²ÒB!„b±(Šh6›èºN’$A€išDQD½^GÓ4LÓTS_mÛ&›Íª6•¾ïãº.qÓl6ñ±èwdzm÷öœþp?ñHŸøè _çöÃ6£{Ê%‡Î<Ž ^»‘óný­ÅÇpÙ…$™23wn—›G¼?s]ö¿ðT6]ð3νñešê‰ˆžgqécYö™9íò2 EñÑ’v®I’Û¶U?xMÓ¨ÕjhšF³Ù¤^¯«Å²š¦‘$ ¾ï£ë:º®ãû>ÿøÇ?T'œ$IÐ4R©„axžGE,Z´Ó4i6›Ë;5!–Iâ1±Lî&Gsñácyéª ¸ë’½j:¿­MäÌó¾Àhc¤ÏP|ÔÙÎÅǭϫןËm¯$•¿ðƒ ï'ùÜœ1¹MþB|ä†A­VS]iÖYg<Ï£Ñh¨Qi‹Jß÷UM}º0Öu]z{{ ÃÇqˆ¢HíE‘ª³ÃPõ²w]—(Š0MéK"†o˜KküéØÍè>àç<9ç¦NÞ”îî-˜rÌu<9á½2‡ó§Nf³în6Ûå\ýD?‘Ú7¢ÿ©›9çȽ˜¼U7ÝÝÝl=åPοs.K¼ õñäOà ÛvÓݽ5Ÿ?ö*|h&»tïÎ絆lðÖC×pÒÞ;°iw7Ý›–ƒÏ»ƒ——~K_¬-Ï6'_Ä>…§ùÞÌßóÚs7pîϲÉ)²ÿ:òX6=æŽó"?¼àW¼ÖùÛµÓ¹«¶=ß9oFÉ B!ÄGPEär9|ßDz,.\Hª$Ʋ,:::ÈçóT«U,ËÂó<²Ù¬Ê¼§å2¾ï«E¯I’Éd‚@}¤/’$QÙ~!†k墲—¯çô›'qØ™Wq”÷8ÿ}ñÕœpÚÛ¿ñ$ÙÎâ‡ß¨òè/áºißeÒƒße‡‚ÄT濵íaœuØ:tf|^|6WŸ{$Þ˜û¸lç!ó~"ßøá<¶=æRΞÜEÿã?ãâï<ÇÛ”†œ@LßCÓ9ð¸9¸{NãÒS·¢Øû(7͚Ρ½~íW#‡¦·MæŒówãÁoÅ!OEôNø&w±ÒW¬(-¿ '_¼÷ý]¦_ý"oݲ-ξ™}ÇËÿ Bˆ¦b±ˆ®ë¸®«Je,Ë"Š"¢(¢X,âyžªO{ÏÃàâÙL&C__®ë¢išú: C,Ë¢½½þþ~â8Ʋ,J¥•J…\.§Zb 1+ÌÇŸàÄ.cêxØ…õßþ_ùñíTg=ÈÕûÅ>»î<¼ßîž×d‡í2€Å„ýÏç¡ÇÙyGÖ{{ 'üô)*;íNÉÿ·Üð Ù/ÿמþYJ°Ã¶ŒëÙƒ#ï²_ën›5‡I3yàʃŒ &3q\/Ÿ?úîxõ œ¼±µr?1„Á¨Ý¿Í×'ü‘ë^kcßkŽe³ÌHŸ“X»è”v8{<À´fÃF'ñ›CÖGþïB|TyžG&“Qå/š¦E}}}tttÐßßO[[–eÑßß¯êæ£(RSc‹Å"F×uY´h£GV%7}}}DQD¡P ÕjQ­V±m›u×]—^xa„¯^¬V®duÃ/°£J}ÛŒÝt°1_üÌ(Ô£ã6c,eÞÔnqå9n¿àë|q‡-éî{;¾qOïÍyô„õü§Ùlû•my­À_šDvÈ·zþÊC¯Á–SwcœJði·ú"[Ùóyìå Rl³*$Ô_˜Í¯^àÙ¿ÌG–æˆa3ºØõ¸L<épºÝ‘>!!„xéÖ´f ŸÏ“ÉdT—šZ­FµZ¥P(ÉdÐu]µ­ìëë£Ñhàû¾Êä×ëuÞyçt}0ôêïï§Õj©ÁQo½õ¹\nd.Z¬ÕV.3ïæq‡4¡ÐL ‡¼ûîkͰ0ˆ‰ÂÅD ˜3ípf¼4‘cϸš™ŸKÉø× Çpê3>aQ½9: Kž–QE~È×Qm!UàÅÓ'ó©Óß{zŸìkÓ‰¼‘ÿ!5_æÆónåíMNäòÏÜÃ7Nç¶¯Îæ˜ ¥ÐF f9h˜Ž‰ô¯B|”ÕëuÕ}FÓ4|ßO×™ôq×uñ<\.§M¥? »V«U:::ð}_eèmÛ¦X,E†a,ÑGˆáXc+“þ§¹ëñí¿9§}©sñô:‹Zïæz\YêôVÃ%öª‹¨ ùÚÈu’Ã`âŒÛ¹pÒÒ¯buÜÑã$ÿÐþ÷öéÜðÊ޽ëX¾<á3¬è­ß2ãÊçé<øb¾¹Y½0‘iî…ûÄ÷˜õ`²DG!Ä¢F£A –›¦IEª‡|Ú™Æ0 zzzÈf³4›MÂ0Ä÷}úúúTß0 õ¢ Ñh iaªÒ˲°m[-´mµZªþ^ˆáXcÁ¼Þ¾S6hòÈnãÙ¾€ ÿEîœq6w ÙÈÝ”¯ý×64îþÓ~ø[yêQî¾æÛœý€hhé«{cŽ8g²÷ŸÂ!§\Å<£º9·^ÅÙÇ~›»Þ”PóC‰{ø¿ßÅ_œ½˜qÊD €NÇ.grÎN!÷_t%OTä!„ÿyâ8Æ4MI’¨~ñ…BAú¾ï“$‰ÊÄÛ¶Mª”ƶm-Z¤Ju•Ýw‡J¥‚çyêC×u ÃPÛ 1knf‹½G]{ _jÞÄÁ;lÎæS¦qOÇÉ\6uìL&ú#n>u" n9ƒ£?žüucN¿hO:µ mnZÛ¡Ó1å"~õÓÓÙú9\zÒÑõÍÓ¸ô'¦¶ÑNlÞ&£hV^Båñ+¹ð¾€Î=‹];†ü,q|ùüo±eÿœÃóx#w’B!Äj‘–Ò‹E,ËRí'{zz(  ’$¡Õj øÓ…®†a¹\Žl6K½^'“ÉP«Õð<0 I’]×iµZäóy‚  R©†áŸ Kù€z—-Îû3sÏK¿Î³Ëÿ¼ÈÜ¥¶*ìv //ý`iOn›;ôĂ0kÎÌZbï.y<£ƒíÿ1÷Ÿ>ðÊõûÐ[Ü‚Mº†j›ŒÚá.ßá˜å_‚&⎗ðèÜK–ù¬5áëüò__³§$Özö'OåÁ¹§Žôi!ÄÊårÔëušÍ&¥R‰\.§jà=ÏCÓ4²Ù,A†!†a`Û6¦iªÞó†a¨Ï‹Å¢ª‹OËwt]',Ë¢³³“f³I£ÑPn„Ž\qy0ÿ·\;§B÷¶ÝŒË·xã/³¹òªWXÿ¸+ØRzœ !„b5 ÃŽŽÂ0T^Óì{ÇjÚk:ô)-ÇI¯†aH¡P \.†a`š&µÚÿgï¼ã£ª²þ>“^ E`ÞB¤ØÅN]Š‚² ˆ  `ADVì-нWÊ ¢®ËÊRwE¤HúdzûýAÎãL$¸ßχ&™wß½çœ{î¹çž÷¦ ›Í†Ýn§  @+Í)--о V¡¨*u.˜7˜Í”¬}šéKþÀSF+Œ]Êô1mPÏx+ …B¡8–HF½  €úõë´áp‡Ã¡½åÆï÷ãp8´‡`“““µ‡_‘H¿ßÅb!))‰P(Dii)V«•ÄÄD @£ÑˆÑhÔ^i©PT…:Ì›dÆË™QÛQ( …BqÂáp8ðx<¤¤¤PRRB4%)) ŸÏ‡Íf# ‡1›ÍZ¹ŒÝn×z£ÑˆÁ`Ðjíå[dý~?Á`‡Ã¡½WÞb±h%9v»—ËUÛÃWÄ!ª8K¡P( …¢œpxßñÊÊÊ08íKžl6›ö…R>Ÿ‹Å¢½zÒëõb·Ûq8ÚÛnŒF#‘H„P(¤=Lk±X´ß ±Z­„Ãa6lXË£WÄ#u.3¯8>ÈËË«í.(âeC …¢6ø÷úk—1 IDATõµzÿ®³fÕêýñ‡ æÇ„iÓ¦Õvq޲!…BQ´kß^+q»Ýdffâv»µ’€„„ü~¿–±…B„Ãa­æÝh4‡ ‡ÃƒA´6ý~?õêÕÃï÷kŸs8¤¥¥ 7·6‡¯ˆCT0¯8êÌRY…ŽáÇÕö” xmR(ª‹Ô°ËÛe<eee$%%a0°Ùl”””àp8´zyyØÕd2i%4‘H«Õª}!”ÔÌ'%%±k×.’’’hذ!.—«Â—L)UE󊣎ʨžxlٲ娶§lèÄãhÛBQ]ä›X= dffâõzIKKÃårÑ AÊÊÊ0™L„Ãa¢Ñ(áp¯×«=,+ïž—eåu–>ŸÄÄDL&ÅÅÅÚ[nÒÓÓ)((¨åÑ+âÌ+Ž ja>1ÈËË;f·²¡ƒciC Euðx”[§çÜ&¶}Ÿ©J{Õ[x÷;Üpî¬ñ5cü0¶…úÁø ºv|.â»§¦3çÕŸð5>“kK›;0Ôv¿Ç-u½ì«®÷OQóÄ–™7œÊõ³GÓÚ¦»0£éqù•SQ¼›ßæµÕ{hÑ¥/¹eŸ°®¶»¤¨2á??â®+§±¢ñåüýѾ¤üú=:†«C¯òÎäÎ$TÚB+FϹ‘S5›6“Ñ!cÿ·¨³è?ùQ2‹Bºk¼üçÓXö[7Îme—žÿé\9í ÒÏŸÀü»Ožw-/>øã¯ôòò‡ÓéšX•öª1¶H1_=4ïÌq9!OhŽÜŽw"ä6…ÛßoÌ´EO“þýCL·„SߺÖj³£8Ê >¼N—°Ôõþ)jØ‚y[#zžw!}ck4öáÇŽ½Nfº ¤Ÿÿë1DöòÆðOX¬í>)ªF€m¯<ÂgžnÜ÷ät†60§qŠû=»€/F?ÃEY•¶–ô8÷Bú&âïÍzŸG3ýïʾaå½QNNnªäÝü”·wý«xîþ›hoèK÷Œ­ô½åÞûe];9ªÐ^ÕÇæYÿ$3¿hÊØñÍX07?*êGÁŽ{üüþÕVšüí^În[cóé÷â<6Gh]ïD—B¡Pìã(xÃ2V]ßçàgøô™‰ :­ ­Û\À¿ø(Z÷4S®HïŽNœN'Œdúò͸£\;äe¾{ë†÷nƒÓÙž£ç»â0Þmo1}xoÚ:´íw ×®pï ;W<Æ-÷¢Ó‰³]_.¿û56í¿ÁÁ1ÕíaçÆ„îNrÇB¾<¼“×¯éˆ³ß ¾-­D¾ÇšÐ.Ö|¶: ¥Žì´¸à|†~äýŸËbj& âó‡‰u4¥?å±¢4™þû’¢Ptßõö4ÚæÕ€5%+FÌÆC[ÚAÛ«êØÛxqF櫦3¸‰*­‰+Ž’ßXÉi›Åö7Þæ_ù¥l_½œo"Nš'«@^¡P(„Ø{dXùë½éÖ €³¯{Œ×~=q-U¦²zÉè?•.ýšw³zñæìµd]õr“kÿT#ä¦Ð é‰è+¹ ÖdRí°£ÀM8¸ö X2;sé5çÒ½ÓIdòù×Oñä‚kØìÊãíIH8È£%ëÈ[ã!}à0:V(Í1’qÆ^¾w£îÉ€Ùå¿m9Š%Ï݈Óö×¶Û^Æ)\ɼÿC×»¤GŠO%bSÔ1ŽÈŽO l'qÙœ·¹lNmwD¡P(ê&±ó¦NܾèÖòz`À`%»íÇæýéœQ±H>Rºž¼‡æùOä×Bÿþ?œ¼…üÐY¤Ê*uÊyœ¦3[©ß¦Ìù=³µEÎÚ -õy–?Šƒ€ƒpþ¬ø :Œ;ƒºò†”ŽçÓÑú._o*å––™µxÆ+ÆtNÿû<¯¹ŽÉW~MþÆ+·v%9îj µÏdè³ÿ7ýÏ>“¶Îcìs Y5zçg8È(Ek_á+o&—iÀC‰ ×<ÀÍ÷®!{èTî9¿Ž‚È{h!7_ŸÂ«/Ž£ý_v‡k/F¢eü¸h_6º™wΫG|W ¥ž4’Ìj3[—9Úv¬P(Š’£ú¥QúÀ!Zô=o|¢ÇCó¹ãÉ»Ùð•{™3IÄD·¯poî» #öz ÔBxDDqÿô8S—Sÿ¤D~Y4‹w.ep]x¿µíÀ›þGY¤³¶‰ ìú7;±átfV¹4!ÁÀÁ¢ßHÁ×¼º6HýQƒpX«ØÅÏ» Þ­HÓ‰ÆÞ¤3MMa¶oÍ'DÖXÛ‹qlž?7²#ô'›G÷㵚Xzyo–v~¯_¹ˆLÍ×]Ž+ …âÄ㘽 öˆZHJ±iñQ´l¬;:•½¦ì\4 ³éëݤ5oA‹úÍiœ¢¾ÜöHˆ–ýÀ‚;žaoÏ{xáåǹÿ0• s*Î>½iy¢¿ö,êbÝ#“x¾à4î{qM3ÜñàHVšÅä×{ñôåáÄ„•SFNà¬ç'pïÓñÝØ—”ÿ½ÍÃËvÒ䚇9S{7w„?ßAß)EÜüÞûÜÚÊ þM,1‘Ÿz&=É0ðï^ o—Vcoãôô"àðVæý@¤ÉÍ\Òâ O³Ú Ö’ÝÃuwrÃy-±çÿÀk>ÃÎÄ3™Ô?»b0_Y{1ŽÍ”Ò‚®½ZT¸ÒåËÀ€Ÿ“:÷¢»úØ8 V;V( …âл˜ÌÚ‚kÍfÇÄy\Þëap4¦ç°q̾€[WÉ0“7Ÿmμ/2ç–'ðb!¥Qkzœ;’vi‡^û?fæm ùMûÍÛÌžø6Є›ßûÛ’O䯌RúÝCLz±ˆ>s^bPyYMJîí̵’+gÿ×{?È&µΛ²Ïã]̹g!óîXNÈÑ”>£gÖ­~kf˜(‘ý¯B5gÒ±WSÖ|ø .wÆDÊIÝqïÜ>¬í_ö™áÝ+yí_pÒø 9ù faÃyó3žÜD÷Ù¯ò®$å4Å·¬­X G«‹ñ€GƒShHÃ@€ß?ZÌ¢íÉ Ú”ZîÝÁ9°ÏñwýãL{v §þƒG:¤‘P¯¶ÚîTÜp|Ù‚B¡¨Ê(Ž5ÊÆŽGÌïÚB¾±=#GœE‰Xg|š£Ð±øÂA‡I¯ñ~mw£JÄcŸÏ6 Œm|Y_º$ü3Ѱ?v즚í[Ýçø²…¢&¨mrôï¯ü€âX£lìXQÍ2›R>TV×} ‘Õ\Ù<‹¬¬¶Lþ± †²š;>ÇÕýœÔÏÊ"«a{ΟðÊ¢ÕÃdçŠÇ¸åâ^´q:q¶ëËåw¿Æ&·®/‘~|j<tuâtvâ¬ëfÕž§?Rñ°öö¾\ó‰6Îd@›}eýØ€¿FÆfÏ#hÓfoì©x¾ãßø g8»qÇW.~ txyxÖN$×y!Ïl/¿ ôË.tât^Î[r.ØÂ‚³œô›»_Œ×Å—;•·~‘o¸¹›§³³Öì;2ü Ÿ>3‘A§µ¡u› xâ/EëžfÊÕéÝqŸn: Éôå›Ù¯öòã¶!/óÝ[÷0¼wœÎö ý8߇ñn{‹éÃ{ÓÖé¤m¿kX¸¶ˆŠ’ŽÁ®j’¨‡Í¯OaÈimp:ÛÐûò¼ó_û{s -”ðs¬xñ.ŸÖ§ÓIî%w’÷‹—š…ã|8÷éªâ¿Lù¡¼˜*ZƦק3r@'œN'­s/àæ…+Ù­Ÿª•~æHõ^D(]ÿwéCûr9tês1c—mÑù— »V>ÎøAåŸ9µ+.ŸÌ«¿€p ö0ê’Mn|Äf «müÅŸÓèÑäp÷A7áB¾{r çuÙ·Ž}ý£|¾bV%å¢U‘KÝðÕ[£gO±Ì·š"–¹«>ªê"ì}÷jÚ:ŒWwVôz¾ŸçÒÏÙƒÉkÝT.¯m¬.ÉW²ãÓ¹Œêßþ0¶\UX®—AOñþ·pA7ç!ÖâêSÍÌ|2ý–|Ïçoþ³îvðÈÊ'è›d!¥ ‡½.BÁ§·sÎÈWq\tNéJêŸ+Y4mü™À7ϦAe9"®˜ÆÐ›ÞÂ~îxæÜÖ‘”‚¯X6w# |´è"rL!v¼>Ž«çÿ‹6WÍäÉþõ(ü¿§˜y×fòI;D»:M{y%—qçÎëyiñ¥ä XRs°ÖȸLd>ŒÎLáõÿÛË¥Cê³O¤~¶½ÿ¤ôgvÇdÀsÀu•Ë£^‹´6}ÄÊ %ü­i”üÌÊ_¶°b³‡Ë²“ü“5;èpz3ì52Þ$N{ðsÞøpƒçؘõöz§¦îç̬7–û^^Mkãf^žtÓoiLç÷ÆÓªfŒë)×ñ܇—-aíü˜ùU ÚÖ³av¾1žËï^KÓ!w±ðÜÆxþù ó¿‘‘¥/òÎÔ\’ ±|¦¼ýj齆pÏý7ÜÇç-G3ýÉ>4µ–±ó—Xçò²/T “ÿùß<ö=Lýn`Ú¢\r"{Ùüí¶…¥Ûc´ºdÓ•Ï»žumÆ|Í_üÉnWƒø³ÂwWºŽmy,×,ØB—Ñs˜Ü;‹¢oŸç¾¿¯g7©‡¹YUäR7|…£ÊkT%öäþ©’ùV“DbŸ»•ê£ m`$«ïÕô³ßÌKí`ÈuÍʃG?¿ò.»s.bd‡DpW5yUêÏjM‹¹í± ÷ W™¶òæü…‘]µýᆇ™“q;~0vÆÍäM¹!¶µ8ªé‰ س›Ð¤žŒrš4£Y €ûð—6³ìîW)êõŸücMÌèÙ8ŸîCà…_.âÎÖ54óÛxiî[çÎâ³G†ÑÐЛn 8ûºÇxí×ó×d3Ï=¾ó™ñÄßÏ!ÓôêLæî³¸é£C5lÀ–^ŸìD#Ø2hظIyÛ5‡)«ú˜üújþ¼lؾ ’+ï}°“Ô3 CÒA.ŠE'·£ó‹WnÅw~w¢¿¬`KbFµø'_¬þ¾>ílZÁ/'#[%ÔÐh سÒ(ÓFÙšÐ$ ¬\™4,gÖÓ)aðtîÕ7qúi4Ý=€1Ï®£´ÏY¤ÊœŠ4bì’y ohúqòîU\ôä+¸æ~ÎÂAû6I}›ì`å ·xo‹^]±É±e W †3¹æ‰yŒ>Åô¡‡3Ê/ç>ÈÂo¡ç°Ò<=™2ç:z§€,FOºˆ¯ø˜•Œ¡ÕÉ5Ĭ4=%£ü§0»ÞÇ#«ŒœýàC\ÞÄ ¾ŸyfáWDú<ÈS3/¢ž èÛ‹VÁ ´ì>½þ§n¬ü39å·¨ŽÞkˆPÁÖgqñ·0´Sù}ûœÍeòÀV^¸ÿ=Š»ÜÃ'OŒ,÷±ÐïÜÁZÍbµ­Í:dÓ•/[È9 M_lã`þ¤&9ðþ_x¬Òul#Ï-ù‘„ ÿÁ¢‰}÷é·WäŸÃÕoæ^U‘K]ñ©U\£¿ÖžBÛ+™o5Š%ö¹[©>ªÐV9†´\u^Wå½ÍGÝJK+DKä¥O i:j­U—W¥þ¬6Õ禥0¢‘ 8‡iéw£Nv1ùÃC´mìÈ÷]CnŽ ę̀ÙSøbÀ”Ê×â¨ÑWS†ÿ\ËÇ¿B—«Ï£±6¿ ¤u½”.Öÿ²jCiË…ó`ÅoÐaøºÓ)ϧ£u;_o*%”ÿO¾Ûc¦Ë žûycÝåÖPÖ¹š3é=´+ƽΪòRßÖwùpW:g iGâA.‰EQs¹=²)ýñvlÿêŸø[_ÌÅœDÁ·?°7ìå×UÿÆ×ät:¤×‘·ž6ïO猊S$RºžWîùç÷êP^®Ñ•kÞ/ÅûÇòõGñ§œÇiÚÛJý6 €–œß3[›tÖm©O åxÌ{šÏ™M÷[–Fg0°y”M«¶¾ê¤>´Õe ,Y'“E1;ÊÇZx7/cÜä/Hµˆ9ì ¬Ãùÿä»=F:éC¶&s-žGÃÈXµÍÓg4ª¡÷šÂœÙ†v©ù,Ÿ>ƒÅï~Åæ½¾ ¬pþ÷¬úÝ@ç+ÎÕùØŠÄlÿZ›uǦ+_•ô\kšÿÕŸÔ(Ü?¶uì'ÖíµÒå¢Îû4C2í/Èåp)—*É¥®øŠ*®Q•ÙSe󭦉yîÆ ªúH¤ãÈK¨ÿÛ›¼¶ÙD)úæy¾tµbø¥Í±RuyÕ5ùÐâ|úÔƒ7Ь=õu²;"xòºd퟿¦Œ. 89RùZ5zF.ÝE)°þ¦Sɾé¯o³×M˜¬éT¸l.`ÃÄÞ´žø×¿·*ôôà&™¶é³N–´†¤ðK ô²ºÉ8mÝL“X¾zC/Ïà—·?bwÆ™ j{p÷‹<"drÒéíq¼ôÿÊL諽4؉Sºn!û¡ü§àt¶—OZ·ž4ª+ª;Òpè÷á]¼5þJflìÆõ“2«u}Ría¶.Ím?ú ég¡= ».;a01`#ɾ¿AƒÉ‚‰árç«k4H®G²^¦dê%ƒ¯ÈE0 ©«Ø‡Å^ñ­T#„jÉÛFJ¾aþͱ±ý$ޞ؃”ò1…=¸I yº­ÂPÌ)9¤à¥ÐŽé3Zn£z¯1s¹ûÙÙ$Ì[Ê’Ioóä¼ñ³îaTÇÂeù”‘ÀÉYŽƒ«µ*ö/—Ô!›®l|±éÙ\kÊu ?©i¸L똻‰d&W·)9›ƒÒjmWE.uÆWØ«´FU:_*™o5› ­ÂÜ­LÕðöÖÃvòs¼øÊ¿™Ð¦«_üŠ@Çi ”PUåU—ä+àÿ1š1éd›?<Äi­# G…¶HKˆa-Ž æIÙ$a¦çüxè´݈{NÃë)1“DLt›ñ ÷昫6b¯×ki&‰ø(ñV|à#â-®óï07fôbXw3w¼¾’ݵã÷yö`ËÇ$Øú Z2›/~øžÐÿÒèÑ=‡Ä¦}èh}“ÏXÇ®ÿYh{kó:ur¡ŸÑ¢ïyãÛ=šÏd–ÿÍÍÞÀÑy\7V9Ö(®?qE@K6„]üé{óäøy…lx'ïMÇK®sxèåkh©3°}2÷_ì'J‚¦ïPéJqÐ,ÙÓg¨ù3“j`$éÔ!LfÓ‚Elûîcž›;‹979h÷å}tJÊ&{ó½Æ)TÇþë’M›*_lz®Î5ûm£¶§Œþþ±­c$à¦ÀUqçví•bă¯s¦*kT¤{ªl¾Õ`…ÝQ]»ªÝ–åd.¹¢-‹}‰o¯ìÆ ë ô˜Öþµ¥Êòª;ò•Øüá!Œ/ÙIiX¿—°«ì-|-®Ñ¹~/Î=)ĆU;Éhyà›)ZÒ,­æÒ¹¦ì\4 ³éëݤ5oA‹úÍiœbƔՉî9^֯ت Þ}üwÕ¸Ûº³ÕAïþ‡öjc=‡õÀòór>\±œÿÌâœËN=Ô~1&y˜2:ѧ‰—uÏ<Ë?íè{’-ÐÒËWÏ=Ï¿ÂÍéß&¥Ö¼C û D-$¥ìÏ6EË6ðÁº®±Ê±Fùíc¾Ü¾ÿx5øÇ—|ø«Ö}ëÖ¦ëÐxÙüÔ8þþe:W=>›õ+d¦ÌÎô¨aýò5äkûnÛ>þ„¦6ô;ÅÓgâ ƒ%½G0éÖ\Œ…›ùŸ+‚)«ý›Fùñ¥Oùã §Õ±ÿºdÓ•¯:zŽgÛˆuËÍðãûÿ¢T{ˆ¼ŒŸ?üþ/¯A¨ÐvœÊ¥*kTeö¤ç`ó­&9škWõÛ2ÑàÜ«èæÿŒûï}’Ÿí}¹êỗ’U•WmË7VŽÈþþŸþ¶?ÐüöþvtÖâš,¬§rÜ‘¼4òZοövnÚƒ&¶2vÿwk¾ø•Óæ=ÉȦ5Ô%kKFMÌò›neÄ­7sýÅ]iduóçöM¬]ý¹3æ3¸Ñ©\us.y³¦ðPÏ'™0 …«eêË;&‡iÜFƒ áýwyíÓœÝÈABN ZÕ?ÄQÞ1ÁHFat·ŽgÁ½ eà²Ö‡ÙæÆ$XsZ—Tžx{#t¼’Ö‰€1öýRðàV¨5]²k±¦´ŒéÐÜÇ’'^âŸm¯¥a oÏžÌ{ÅpÈNUˆUŽ5‰)Ÿ§ÇÞ…iÂ`Ne3o=8ŸÍYƒYv^ýš?%¨Þõ óðÏÔþ(—¦ÿɯ[ÿÜ÷ƒ…´FMÉ"Isµ IDAT²ŸÊ߯õ&oêdFÏ(fì9Mðþô*ó–üN£Qs9§ž 1|&ðo|Œçî Ëy}h×,[ÙxoÁwDN¾™öiF°žÂ•¿„×nžÁˆ1»?¬;õ£{Ù²ö+ ÎdR»jØ]²éÊÆ×¥zŽÅ~ê*1é¦ WÝØ™Wï›ÀøFÓÝ'“¢ožãáÏü@"†C-Jñ*—ª¬Q•ØÓxDzÃÏ·äh®]GÒ–)»?ëcaÌ—ù¤^rÝÓöP¥þéªúù:ALsîךJy~ì$l·£a#ËXÀÖ£´×pšÐHæ9ñÅ›-™1ç)¦\ý^¬¤5mKï ¯¥c>Xd$cÀLÞ|¶9ó¼Èœ[žÀ‹…”F­éqîHÚ¥M†-b™k*Óï<‡ÏÃgê>æÌvtH^Í»~ÄãÅ~0¥Ñâôëy|úMå¯M3‘yÆl^_ܘÙ¿Ì=c—ÆAÃ.¹é s5í¿.Ùt%ã«–žãÙ6b[Çš|‚§Ë¦2}É$®[l£aÏQLœ™ÅìÛ~&íß:¯r©Êux{2'V6ßj£¹vI[†Tº^ÖÓ—¿páÈŽž»¨Ü?U¤ªŸ¯?l3†‡‡üÌC÷\ǃ²Ï=:k±aÆ Ñ5kÖpà 7PPPpÄ ÖÏ?ÿ<&L`Ë–-µÝ•£N^^Ó¦M;.Çv0N´ñÆÊñ"—ãeGƒ]'êøëƸƒl[| ŸnÏ « {¬M®r:úÄý¸¢¥üß„3ýó¼ûáœu,è®›ò-cÕõ=¸¡x&kò“}óyyyäääÔtf^¡P( EMÜþ.‹Þ*ÅÙÅIƒ¤;¾Éã‘G·qòMÒ¡òŠ:HÔÏÞ­ùeý›ÌúÈCçCiQÇùÌ+ …Bqc0›)Yû4Ó—ü+ ¦ŒV »”écÚÄÉCðŠZ'¸WÇgÑoVšws5Ž‹g®NT0¯P( ÅqŒ¹á@f¼<µÝEübmɸO73®¶û—$ÑïØ| ïOÀ) …B¡P(Šƒ ‚y…B¡P( …"NQÁ¼B¡P( …B§¨`^¡P( …B¡ˆST0¯P( …B¡PÄ)ÞfóüóÏ×V?Ž yyy•(N9žÇv0N´ñÆÊñ"—ãeGƒ]'êøOÔqW•ãUNÇë¸ê 'š|+|¬B¡P( …B¡ˆ–.]Z13_·¾þVq$Ôͯ4VT¥G…eŠº†²Éã ¥Ïø"//œœU3¯P( …B¡PÄ+*˜W( …B¡P(âÌ+ …B¡P(qŠ æ …B¡P(Š8Eó …B¡P( Eœ¢‚y…Bq”±êú¶8‡¾ÁÞHíõ·a.ýœg±`K ö:¡8 òûG‹yìÕõ”Ö¢ý+Ž%ÖÞÞçEÏñ{¸*×)Û¨Û¨×øÖ— æ …B¡¨~ÿh1‹^ý7eÑÚî‹âØ`ÀÑàZ6KÃR¥ë”mÔmÔk|ëË\ùG …âÄ öáÇŽÝTÛ=Q(µÍ>à Ã¤×x¿¶;£8Ê_zŸÌ|´ŒM¯Ogä€N8NZç^ÀÍ W²;$(?îôï?q tsât¶¡÷å3xç¿>*n´‚ì\ñ·\Ü‹6N'Îv}¹üîרäŽVlkðs¬xñ.ŸÖ§ÓIî%w’÷‹—8Ü´ÕA"”®;‡ô¡½Ó‰Óé¤SŸ‹»l ~­{š)W¤wÇò¿Éôå›Ù§¦0{ÞA›6#xcOųOÿÆ9ÃÙ;¾r•ÿ¦2}+Žœ ;>˨þí3W*ÓCe:/'RÂOç‚®NœÎNœuÝìÚâ¯Ä:ÏŸáÓg&2è´6´nsOü¢JuªO¬~8F]‡ ùîÉ1œ×eŸ®Ï¾þQ>_1ë %UÕ™ã•ù ÊÚõ°öö¾\ó‰6Îd@›}mô`þÈ^Þê¤ÃÍk(ÓÝÑ·~}œçðøÖ`奨>±ÊøPþ ø€rŒXâƒÃØFíá8ãðó=œÿº;Éÿ ù„wòú5qö›Á·¥2E¯ñ¯¯8É̇ÙùÆx.¿{-M‡ÜÅÂsãùç+ÌüFF–¾È;SsI6”tÃÃÌɸG?˜G;ãfò¦ÜÀ£‚d}x½S @„ÂÓzÓ[ØÏÏœÛ:’RðËæNcdƒ]DŽdå~^ÀÌzc¹ïåÕ´6næåI71ý–Æt~o<­¬µ$Šã÷÷ÜÃ}|Þr4ÓŸìCSk;ùu./ûÊÕ"”nߥËÜuEc2~~ÿ6…S¯Æ›ó óNO%ëôatf ¯ÿß^.RŸ}jó³íýø#¥?³;&S%}+ªÏ¦ÅÜöX†Ž{«L[ysþÂæJ,z¨\çBìx}WÏÿm®šÉ“ýëQøO1ó®Í䓦ëPUæù#Ü›4š™Ë>åÔ/‘¬8q‹u™üp,ºÞþòX®Y°….£ç0¹wEß>Ï}_ÏnRu7«æÁ¾Ý é4í5æ•\Æ;¯ç¥Å—’c4`IÍÁJñQ–—∉UÆñ¬½ÃÆŽÃ؆âȈa¾gÉ´û/bàÍS™ñi=?]¯OfÖ×é\ñÂôøËœŠ}ÅǪåÛÈ3 ¿"ÒçAžšyõL@ß^´ ^È eðéõ/08§ü³ÆŽÜqß5äæ˜€ÎŒš=…/LaáÇ·ÐsXLm¼4÷-ŠsgñÙ#ÃhhèM·œ}Ýc¼öëyŒkYÞ–£'Sæ\GïtÅèIñâ³ò1´:9>DWW l`}qßq C;9öý²ÏÙ\¦}ÂB³ÁÓ¹WÑé§Ñt÷Æ<»ŽÒ>g‘šÕ‡a] L~}5^6Œ&À¿•÷>ØIêÐ! ˆIßU«„T„P}nZú#™€sè‘¶‘~7êæJŒz¨TçþM<÷øZÌg>Æ?‡L#Ы3™»Ïâ¦t×Uež›:2iþXά§vuGÊüp,óÛÿž[ò# þƒEû’jzu¡Aþ9\ý†îºjÎñJ}PLíÖ';Ѷ 6nRþ ªÐU*/Å«Œÿâ<æ+‰l釰 Å‘ã|Ïè?•.ýšw³zñæìµd]õr“ùëöØ÷úŠ‹2›pþ?ùn‘ŽCú­ ØA‹çÑ0òVmóíÿðÉè’µ_ ¦Œ. 89¦UÛðáüXñt~ƾà)ϧ£u;_o*ÝìvRÚêvp–¬“É¢˜ÅAG†9³ íRóY>}‹ßýŠÍ{}Yÿ"¥ëyåž¿q~¯8NœÎ®\ó~)Þ?¶Œ™ôÚã¿^gUy©oë»|¸+³†´#‘*ê[Q}ZœOŸú"` ÍÚS_7WbÕCe:ßç ÌtÔs_ `L£Û \ìºîTIïÍûÓ9#ÎÁö/˜|å}|—ó7¼µëþ*ŽãŒ¸H/‡=¸I yº­ÂŽÊœ’C ^ ]a´}‰# ‡þCÆÒÀWä"KÙ\À†‰½i=ñ¯÷jUè!‚mß;}[#„âðµEuŽÄ\î~v6 ó–²dÒÛ<$9/dü¬{Õ1cxo¿’»qý¤…Ìj]ŸT{˜­KFsÛ~Bûf+§ £›iËWïaèåüòöGìÎ8“Am÷-÷á˜ô©2_GŠ= {…ygƤ›+1é!àíJt¾Ï$Ó6½b¦Õ’Ö~Ñ~ŽMïåóÜ‘†#.ÒqD%~˜Håó;ì.ÄC"™É—)Sr6IºŸ«=Ç+ñA±µkÿëªCeò:N%VÇêT|P+Te¾S;rIÿLÞX^@ËËGÐ!éøHqÌ›3IÄC~±Ÿ( Úœ •î¡Í’M 9’’”†AK†KØU ö–ÉX Ò–‰n3^áÞÜÄîdÄ^¯&• ©Œ$:„éÏ aZ°ˆmß}Ìssg1ç&í¾¼.îïyãÛ=šÏd–ëÜÍÞ@EÝ3z1¬»™;^_Éî‹ÚñÎÇ{È<{0å±|ŒúVkbу±è£JunJÈ$%ÞŠ=G¼Åx«x?ý¿M‰$à¦ÀUñáæ°ko…‡J«?Çïƒ:ÅÔî!3°˜ ­ÙEƒ^ö¨veòRª c%òºKìó=Šû§Ç™º¼˜ú'%òË¢Y¼3p)ƒã­~&Fâ"eÊìLúÖ/_³ÿÉd|lûøvšÚÐï]vä÷øô·ýo9üöþf ußæØSv.š†ÙôõnÒš· E ý¿æ4N‰‹ýÍq…Á’N‹Þ#˜tk.ÆÂÍüÏ!öˆZHJÙ-ÛÀë</6fÐsX,?/çÃËùøÏ,ιìTÊ+`•¾ë±è!›²:Ñ=ÇËú[uÁ»ÿ®úWï§8†Tâ‡cÕunv€ßÿ¥QíCüüá÷è½ÀÑÐõÁ|Plí0[-ôÐ×ÜdÕK °ûwJµ5+ȮòRj\Ƈ° Åë|–ýÀ‚;žaoÏ{xáåǹV4û©üm\oò¦NfôŒbÆžÓïO¯2oÉï45—sô®™Jy~ì$l·£a#ËXÀÖ¬Á,;¯üm'Ö–Œš2˜å7Ýʈ[oæú‹»ÒÈêæÏí›X»ú7rgÌgp£Ú艃ãcÜ8w]ÎëC»f9ØÊþÃ{ ¾#ròÍ´O3b¤#šûXòÄKü³íµ´3láíÙ“y¯´H#=†ÑÝ:ž÷n$”=‚ËZë>“¾Ïz"=dÇ sû©\us.y³¦ðPÏ'™0 …«eêË;&U»ŸšçÇŽÊüpz,ºnÃU7væÕû&0¾Ñ4F÷ɤè›çxø3?ˆAvÕœã•ù ØÚµÑ CCxÿ]^û´g7rÓ‚Võhsio^Ì‚r¹«_ÿƒ©Oýh\uy)Žœ—ñ¡lá2ÿGB,󲡇uLâù‚Ó¸ïÅ!4Í4rǃ#Y5j“_ïÅÓ—7>HðßúŠ` -äÕðÌ|r>ã^óCÊ)œ1f ÷ŒÉ­ø@C›1<<ägºç:,6ÙqsçN¡wªö´fòæ³Í™·àEæÜò^,¤4jMsGÒ.-.+âsf;:$¯æÝG?âñb?˜Òhqúõ<>ý¦òW¶àÚE³Ù1q—÷zé9ló†/àÖÕÛ2¤wgxOkVûɹê2œûJßu€ô`Eçfš [Ä2×T¦ßy/xÌdwĘÃY|××U»ŸâØQ™ŽQ×ÍF>ÁÓeS™¾d×-¶Ñ°ç(&ÎÌböm?“¦}³Wõt]¹Š¥].έk&³tÂ(– ®}“OîjKZ¿<6fwO½ˆÓ6öÁm÷bþ„ïª./Å‘Sã26Ò6lÇèŽ'•ÍK¥ß=Ĥ‹è3ç%•—Õ¤äÞÎüQ+¹rößy½÷3Œhr`»ñ­/Æ ¢kÖ¬á†n`Ë–-µÝŸ# ŒU×÷à†â™¬ÉLö îóòò˜6mZœëT¡ô¨ÐS÷íáXûá Û_ÂÀ§Ûóªèî¨üŠºMü¯[Ê&/ê¾>zòòòÈÉɉ—̼B¡P(N4‚ÛßeÑ[¥8»8i`Ç7y<òè6N¾éA:Ä} ¯P(GÌ+ …¢Nb0›)Yû4Ó—ü+ ¦ŒV »”écÚ¨C …¢œã(˜O¢ß?6°¹¶»¡P(',G×›dÆË™q”Ú«{¨uëØ£d¬8þQÕc …B¡P( Eœ¢‚y…B¡P( …"NQÁ¼B¡P( …B§¨`^¡P( …B¡ˆST0¯P( …B¡PÄ)Þf“——W[ýP#”N”z”=(êÊ&/”>ã í`÷ìÙSÛ}Q( …B¡P(1Rá`§M›V›}Q( …B¡P(U`éÒ¥ÇÓ—F)E«V­˜L&‚Á ~¿ƒÁ€Ñ¸ïщÄÄDŠ‹‹ ‡Ã$%%a2™ƒ˜Íf‡ƒ@ €ÇãÁjµb4 …BX,B¡fó>“òûýØívB¡V«•`0ˆÑhÄd2Fðx<˜ÍfŒF#f³™²²2Á`ÄÄDí³ƒp8Œ×ëÅáp`µZ‡ÃƒAB¡¡P£ÑH$Ñúk0°Ùl B¡P…±X,Âá°6þ`0ˆÃáÐúl4±X,ƒAÊÊÊ´±Êç½^/v»¿ßÙl& b³ÙƒD"l6&“ ¿ßO  !!“ɤ]#×E"Mfáp˜H$Bbb"ƒŸÏ§é0HII!b±Xðz½¸ÝnRSSq»Ý˜ÍfL&GÓ©ÑhÄåra±XˆF£8M^¯W“@$Áív“ššŠÏçÃl6ã÷û‰F£Úÿ§¤¤`³Ù())!‰`0p»Ý¤§§k:D"„B!‰F£ô"¶‡5»Ûðù|ØívL&“fgÉÉÉFü~?^¯—„„l6‹E»¿´ …ðù|˜L&Ìf36›M“K4Õîc³Ù4ù–••a6›q8 ¬V+EEEšLm6‘HD“Y8&99¿ßÉd¢¤¤D›/~¿Ÿ„„n·¿ßÅbÑÆàóù4Ù†B!­ïV«»ÝN ÀëõjýD"$$$h6àp8´~D£QÜn7‹£Ñ¨Í%™çF£‘@ @ZZšf‹EÓkZZ‡ÃA(Âápàp8(--Õæ¼Ø¾´™˜˜¨µ0›Í$%%±sçNM–©©©ÚóûýD"­ƒA›wÒ_!‰œœŒÍfÃl6SPP@RR’6nÑyFF‰‰‰¸Ýn±Z­øý~>ŸO»w£Fp¹\D"’’’´¹'v‡1D£QJJJÈÎΦ¤¤‡ÃÇãÁd2i¾Sú/ŸFÜn7ƒAó!Ñh”;wb4©W¯IIIü~?EEEšm iÚ´)áp˜¢¢"²²²ˆD"Ú’9+²¶X,äççc±XHMMÕäPTTD(ÒìFl<‰h>OtšŸŸÍf#k~Õ`0hþÉn·k~Zô/þYt/¾Õh4’@II‰ösjj*Á`h4Za®Y­VB¡&™;^¯—’’Âá0”••‘˜˜¨ÍiYgìv;‡ƒ‚‚L&©©©x<Mo>Ÿ£ÑHaa! ˜Íf¼^/õêÕÃív“ŸŸOVVV«•h4ŠÝn§¸¸XóW.— —Ë¥ùŤ¤$Ün·fâKdº\.l6IIIÚ5›Í“œœ¬Í›P(¤é* i×ùýþ sÅ`0PTTDZZšæÄ·y<Íÿ‹ÿv8Z_½^/~¿_‹¬¥²Ž=õÔS(ŽOT0àõz‰F£Zpîõz+,ú¡PH –eAg&º,òâÔìv»¶ˆÊ …Z€*†â˜e1ÅÂh4j•ßï×5 úäóƒA B-H–ûøý~|>ŸìË8%`òz½šs•,k‹™ÈB²Œ=55•’’’ Î\61.—«B°ŸœœL  bµZµ…; áõzµÅÐl@Û´”••á÷ûµÀC $€ …B¤¦¦j×ËF"))‰„„m³æóùHOO¯°é ‡ÃÚ¢¯ßèI`ãõzµÀZt …HJJÂ`0àr¹´ ^—ò_é—ÜO‚TY°$HIIЂ^—Ë¥Ù…ÃáÐìA‚UѯèHÆ)?[­V4ýËF*j:¹N6šf³Y fdCåõz}¨ô% jA»,ÌÅÅÅšLŶ¤ß2$è“ §lÄ>dA– N61V«U““,Üb2RSSµ§ÇãÑæ@BB‚&¹¯èÀd2i퉾ŒF#Z°#sRdžœœL0ÔlC6õ¢ëäädRSS±Z­¸Ýn"‘&“I³s 0 ™™™ÚVd%6e6›)))Ñ|€Ìߤ¤$’’’4ß#¢lîdÓ :)++«à"‘ˆ¶)‘‹É999-¨{– ©$, ‡¿ß¯mî$0ÛÊÎÎÆãñàr¹´Í°Ì%±AÙ˜J–ššªµ)cðz½’%r/±)¯×«ùVñ=â_B¡æ§E.â+dƒi³Ù(**ªà‹ôóI|“ÕjÕ6I’¼Ÿ%rYF£QÍOƒA-p—y,íF"M2e[s¹\6Tr$€+l$äÞ²9NHHÀívSTT¤ù™²™JNNÖü³ÈØn·ãr¹´ ¸\oµZµMQ  33³‚Üd3”ššª­f³—Ë¥]#z_)kŠlhõêÕÃçóiö°Z­8 +ÈSdj2™4[{”ä‚l Ç'*˜?€UŸ]‘…Ð2•°?ë%¤ðË‚ëv»IIIÁd2i}A¡ÉdÒjùÙjµjÁ»ÜS‚qhf³™p8ŒÇã!11‘¤¤$Í©ÉÂF)..Æn·kYJÉ,™L&RRR´@LäJeñôù|”••UpŠ’¥u»ÝZN²à6›„„Âá°––>ø|¾ ™hÉ0J¦\‚Åh4ª-Î"{Yô-‹–E—ÐI@ @ev»ÝZ)¿ …BZfX²[úöDOb’¹¶Z­”””h*ƒÁ ÁÑhTÛ¤ÈElLo›ÍFii©¶¸H%&ÁEbb"$&&jYP‘‹Œ¿¸¸˜ŒŒ ÍþÑ·^N~¿Ÿ´´4ṁƒ½{÷jv ©_¿¾f?r Üõ d0% —‚ªî·ß~#;;[»¿d%Ó/þFNJ ƒ¶@M6q ìܹ€ŒŒ öîÝK  99™ÒÒRms$¶*–>I"sZô«· ™G………ÚF\ä!~Næ¸Ñh$??Ÿ@ €ÍfÓ:â‹õ‰ñaò7ÙèÈ Q4ÕN¢dÎÉi‘\¯‡èÃï÷SPP mpdþŠýÉiÌ Krr²vÚ¤?íÿ-Y|›ÍV¡ѡȹ¨¨HóãbûÒ?IÈ\” ‰lœÃá°æ§äô"11ŸÏGqq±Öß””Í7ú|¾ óÛëõj›™w>Ÿ„„m½Ûr»Ý$%%aµZ©_¿¾–ÉןÚÊõ‹…¬¬,Ìf3{÷îÅb±h'¹z¿\RR¢ù]}ÂJq|¢^My Ç¿ˆI†R‚AŸ-¶Ûí79—LQqÆâLe±“Ì TÌîHˆdy$@´@V(qfÔH°¯¸¼·>X–ÅCJf¤¿’—1˱­¾¿rR!A‘8o‘‘,àr*¡ï‡dä³r9aÐg¬õÁ© 2n¹^Ø·˜K^‚ ¢%€Ñ_#‚¯°/ëÿ'G¶¼éŠõr—qˆýìÝ»W“µ!r? Hõ2`Q ±'É Jp*}1ÈfH2‡RÂ"r–ñëËj$ˆ‘ UäûËB­pHæV/w ÂD~¿¿BÆ__Ša4µ Wl\l KßE®zùëƒ^)7Ðgæ$'sW/÷äää 6*óEÆcµZñxúÓÅH$¢êHŸ¤¤P6a²” ·Ø­”'Z»zÊ}ôþGÿ7ŸÑhÔNÿIMMöú²9þ‹ÈIŒl åŸÛíÖ2ðr½~~&$$h²éOŸLÒˆî¥}»Ý^ÁÛívMþ&h\.n·[»¿ÞFÅEž¥¥¥šl$i!ã=0Ã,r”ëÅÏÊ ƒèM¯g·Û×ë­pÚåóù´þJÿ¥TÏáph¶#÷J’ÈáphsIü™lP ›$‘»´åv»+”l ­ïRN&§/2ŸEV6›M³)±?ý‘SB)1ÔŸhJRIä Ÿ«b‹²™ÖÛâøÄ4vìØÛ·o§k×®µÝÅ1bÁ‚Z°"Z_Ã+Ù qX@…ÅL¿‹3‘l…8? BvEœ©´!™ e¡‘€ÐÚ— C~/uÈ’á‘ «ì°/È5 $%%Uœ$(…RÚ—š_8rÉŠëO%dLúÀ]²Á£Z~ IDATÈB"ÉØ‹3–i[ä(ÎW²Œ’U”Í•þ4I&Q_.!ú“ ¥>Ë,= hå:¹‡ŒIô&²M´'å:²ù’þ‰Ì¬V«–Õ–ìl*ü~?eeeÚQ¸ôAìC6JúŸõÁ½œ¶è7 r*4ÛÕH~¿Ÿäädm!÷z½Ú™žžNZZš¶F£Qíè[JNäžiiiZ?$xÍ¡s²PKÿ%+/6YT¥œÐæ€díÄ.¤tF,©õMOO×J¤¼Gô!ö …*d¹EÒ/™‹úӻݮ•Liv‡+”5ɦIŸ?!²HNNÖ2º”K !ÏUHM±ÌY±+)ûÓŸJˆL%À• ²ÈQÊeÞ‰$øIIIaïÞ½”••i'f2×Ä·•––V(…ðx<šLÄ–õ‰±;Ñ«¾ìCúc45™Ji‰k’é[”ădQe£!›Y)Ÿ&sMê°eÓ §"â3õíëKqÄžôÏ!ˆ¯¿¦÷ÒñË’ü‘qË GBB‚¦s€ôôô þÁãñhõ?ÿüS›câÏÄÖôÏäHyœøÙè{<­LK6›òŒ@aa¡DËNd%ëŽøHчÌÙøÉ&FÆ%'ÈúŸþyöFì3--MÓ­ø=‘™øýæI672—åÿ·nÝ Paã¤?*,,¤¬¬¬Â©þ9ÙȆQ|ûÙgŸ]µàAüðÃªÌæD@qH’ñÓK¬°G²RN 5Û°?û,NUÚÐ!Šƒ·Z­ZM®d„$x“c|}vQŽ7aݺds].—æ¼ôu˜’Ö–Ò†d=daVJ;äó&“I;>ÖβÈè³seeeØl6- '}’ ¿,HÉÉÉZ]°,òy.A6 ’MyJ€¥?Ö—àUä$÷‡ýJÐ!mÊI‰,øRzh ‹lJD^|J½¨,%%%Úu)))„B!m÷x<ÚÂ#ÿdÓ¢/ÇÑ/>úzY Båÿ%ȃ”––âóùÈÎÎÖŽ‹E&bÏ"+ äaFÑ—”LI6KjcÅ~Ün·VÊ%ã•̳þP ˆ$HHHÐô!úÓÕ°ÿ@6Eú§ÂÂB²³³59ÉÆáÀ,> eØE~r”.ÙBÉ$ŠíŠÍ‹L&“ö¼ƒÍ©©©Z‰èödúÓ™7ÉÉÉÚÊ, JKKINNÖêÉSSS),,Ôt–’’¢ÉM²¦’,’" ¶D>úÚõ¢¢"-[;”g~vîÜ©•,èç¶¾$33³Â©XãÆµ²yÀ;‰PRRBzzº„ê762F±Ùüü|êÕ«§e2Ÿ¤DEJ ¤J2©bK"[)”ˆNÙÙÙZÛò0©œhIÀ'›ØP(DFF†6Fñ7‡£Âó Ò~$¡´´³ÙLýúõ5_‰ì[ü·ø$yàXàv¹\Z»PÊ\ÍÌÌÔ—S y@SÿÜ“Ì ÊÅåw²q´qÊs‚lÅË|“̾l6%¸–ç“d£ r‘ Ybb"ùùùx½^rrr´g1í”AÖ;‡Ã¡Ù©Ü'??ŸÔÔTíaT±W±9y‘yY¿~}mÜÒæ›k)YÒ· …HII!Ùÿ,‚þDQqü¢‚ù}- 85y*ÐŽ!åU‚gyèT_««¯ù” €¼ C\,‚,˜€êù%Û¨/‘ ¥~‘G.¸dÄô™dÉHK@'·JM¢:úÓYHù9)) ÇCQQ‘–•“ «¢’õЗõH?ä[ÿ6 ¶äÞR£/Y>É:JÔeëË äøVßOÑ©ÔFêßP$}?X]³ÈYŽaSRR´ §¾þöPrOYT$X´€XfYôe¼rOѯ¾Ü@NÄ$€—…^·äädÒÒÒ4;àAÊ(D7b³"×Ý»w“••¥eøÃá0¥¥¥Z]»Ø¾îXä§/K“ÀEÊb bù“~S*ÁŒ,°bÏR6!úyz<mœúM£>ãn4µ ±dã¤6\2ùƒÁ@II ©©©$''³{÷nmC&2“kd,²¹´´¬¬L{`\ÿ\ˆÈ@îe4+ôQNM$xì©ü¬û‰dnC¡™™™Àþºc€zõêUØÈZÙ…¼ÍDt%§aúÍ´üM2Ø2Gä-Ez_¨/'”¾ŠI¶TŸH0 üùçŸN($°’Ÿ‹ŠŠˆF£Ú) ¦C¸´´TƒÁ –––jqq±I{Š9ZUí¤ "ØPì´äTMF%ôíêêj½ÿ¾Ö××È/..¶ƒè³òjìEœîÌ;ÙÚÚªwïÞu¤)°½½]777uppPí숄˜‡õòåË1{èù~o,H‚´Éç윩ËË˱=QNËììlmnnv®[÷|}¼×3˜ÿ.ÀÜ¿ý,|U5 Ê?@NÕ¨RIjï‘ÔèM^@Cê¶}§ªšåJ ”€©ªº Yã,I   T±Iú¤6Úfân2AÐÏf?X§¦¦ºo&5Ü6Ú¼²ý€D¸Œ<…Êž ÏúŸC@v‘Ìlö.+Õd\tž××× ¨ÿR.AÌ5{>ŸŸ¥P2¼©ÁÎïM&rrì|W˜ñ£)­ª–é@Ð;ƒÞüsnjãd²°{eØ:Ç×<È$¿_wMÎ}è3YuÅ\¶¶Œµ¶§Ô8©%$¯­­µD xô" )#ÊäBã|}}ÝÌ»Ò"L"4@tŽ'd¿˜¤J £ÄÄI§BŸ È3ªªYýi ²Ü¥{·¬d͒Ƙg)#´õV_±‘@ŸK5$ì~&¹.,,ÔÆÆFWÉ:>>n‡´ª::áþIè£tzonnºœ¬ñÊr•ú!%PItˆ¸f„„]ÜÜܬ—/_¶dÎÜ÷·16ïзUã¥sÞVÕá“Ñ®lû" `|ô'»O™vÏ7®z&™sÜØOmçp¶½´¾°—åÞ˜¿“¯¯ÉÄ<óòò²>|øP ðmMÛêªço®{ªh`ÎCmµæž¯÷zóŸÀ•¥Ñ’}Ä´dµìL aÂߌ»ò_)ÉzÀ©¿¬±ÅJ¿¹„¥%cbxµ1÷€¹rjÓLþþÄ Ó¦2Š6N¬,€A¦#(ãûøøØabmf|www a‡°mU5ƬcmY‚xÃD©tww7VRzÎÅqJ@ìþô°éÔ˜¾›íÑöÔEáYÊíË/¿lý4°­:…±K¶°Àä&[oÌI1ô`g,i¤m¦9o>ÖêêêX$ Ùr{{Û¥q'çÑããcWÿ™ùÏ×Çw='À~׿øÿ¢ªjŒ‘¬ qc(sÿ¸”`tÏdË2Ô È“:äL|KÍŸP$KSU½ § H)BmÓÆ4«Üجl*Øj€óòò²å6ùŒ:p€´eii©5Š™Pjãͤâ¬*”Zrò˜,ý‰IQ)e}}½CÉ6ãÓÓÓ±¦³æsúÙx ï_^^ŽíÌ Ç![PºS8ÛXa÷H΀šÞ"#úÁøÙ„r|õ¿9¦/DYüL’.gR"å`0‹¨’(ã!Ú4YÄûç»ÔÉ's¯_±gÀaÊHHÄ^¼xÑà’ K?nnn¶l2·¼g†á%ªåæ7@”Œ&°KN’ *¥mUÕ¹.úÝ|øÐ¶¦ªº‚y ôJ^__ï(PŠ_[[«ÓÓÓ¶_ËË˵¾¾Þ¶Ý8˜;ƈdCØ6Ÿ“j~[œlõÑÑQÛRÎ???z=;;ë2s˜™Lt€Øö'å3€’`šƒàÀ–ûª£d‰¹|þ¤S–@,+Ô<>>vÿØ(o‰­æ &3øœ[)Á¼§Ü$KH¦Ä˜Ož5ØE|PQ¥&£€K² =6ERs)}“‡Ša¿ÍO§·:Y4׊ï$ƒªš‰uå6ß1~œ ÿÞhý‘ìyFª²2 Yç+¥&™¤—óªªííížÃYv’ì0SvÑúͨ†AU1Ê»baSƒî}±ß@- l<1 NÖµžHüÌÅÌ%a£Ò¾ý?e~iü ¨Y_ggg]ž­å´ÙÏœ©tdIo2J¦SÃnNX§±”_åZÍ‘x©}l]æp¸·dP9}¡ßæææÚ˜÷ð$€nëÅzµö³ò›D€BdU樿±è€rÎ ŽGÓó%gôogg§s8(———uzzÚRL½ßycÌ™–”k~ìq@´Xœð´5 ä€2¤’ÌŸ¯óz–Ù|ןüÉŸôfhÛ|Òh)wt’ML† õÙD°ÑäBÅ“zba_ ‰!K)NÐLÔ²y$“­€¼°§Ð?G^acÄgòtVRÆï¾æJ‚eö–so¾ÉçRMk2߯¸ùžµœ'Úb²Ùü<Œ P*òææ¦ÇÓºÐNN…5'ŸÅ}œM`¾š_@~e{C·TZ2¼³Ü"•Ô¦¦¦z¯ÔN9&œÒ™™™ž/ÛÛÛõ›¿ù›õío»Þ¿ß%k777Û¡ž­ôþÑÿ7ñ|ýÿúz–Ù|"×ããcœœTÕHãn³fŒ’-§á¶Ya_”ÇÇÇ1Ö„–À³¡?>>Ž%˜%{˜šúL`Lý/฻»[§§§ý3ía01÷Jô1ô/_¾“ø0®6ôÔ;Ú„WWW´a88 Œzn`î'É‹S155ÕœpŠ8 î£Þµ(à%e.™®™fÔf‘NOj}IwªªK!’M ‡£ä奥¥å:”ó‘ ×Xa„87¹KîKv,sò@$lž~uuµ.//[l“·±U…yÎÌàììèRýOúáÀ ºÝÔcû®ˆAéix1Äž¿´´Ô5ÄÉ_ªFuüå`U=÷ííívÔÔÍ·‰k‹Ð=€TU þèôÞåý9 UÕ‘£ùùùŽæè/ò u°ÓÙ3ßËþþ~U$NÞ‘Vž àœÌÎÎ6«˜Œ¾µHBäIîævÒÚ¹ººªííí&'ôq=;;ëç˜3ÕD8tœÃééÑPUOåZé¸Ýk0´ÖšÓ¢?Ìë‹‹‹–©YÞ'ç´÷Z__¯ûûûâ)cOú”í ‡Ã®µ¿´´TßúÖ·jyy¹Þ¾}[«««uxxX§§§]£_dʱ´´Ô’”ƒU èäe9ìÑõõu—Jµ‡L¶‘=`—Ùfû‘¹aÞ³qö ¥Uü27­µûûû>ÇA¾€w•§Qõ¥ñÞKKKµ½½]=¦½%©€lXXXh©Uæ™Ø?:ªäoó (GYcä^lÚÝÝ]­­­Õþþþ˜S¼±±ÑöYûH÷HÅže6÷5ýŸÿÈóõ1]X@5ÿä†å÷ÈV2ŒŒs¾ãs®,Ýèw“÷ËŸ»uI˜ÚéyŒ·Ûp&Û•¥“ÕÊð÷ä÷ò¾yiiÄä÷²oòÈyÀ×ý0uY ¢jTÏ•aÖ앆 p˜ò¾ÆàÈÏ&Ç,Ûe¾þº¾^8‚~fþÎÎÎv¹À¯›‡"ù}‰ªƒÁ ß…|&ûíâ⢿çs½¾8}IË¡ ª¬|Ìzþ<Ëû]\\4Óªs®ÈÇð3,²¿EzüÛ{çç'ma¶osÊrnˆ øcÞNŽ}Õh=¹€ãÉŸ{'ïígÞÇxëlrÞè§ÍÍÍÚÚÚªÍÍÍZ[[ë?U5fW$O¾»}}™ì‹´æ€>ÏõŸà4ç[àý´]?ùN>ÿëöŠÜDB&?ë3æ^έŒk¿½0ß7mÛÁ9æ¤zûœë ßÉ~fýºW®ç´ž‘ý]õTÁí‹/¾¨wïÞu[ƒA6Ûü|}œ×33ÿ‰\y#"d 䕬ö£‡ªž3‘`š \y8&ýìì¬C.ŒÇååeÍÏÏ7ë"$žÌ~†‹1̘`‘LkÖ·yù{Ic3#·Q'cÒ¦¦]?ä0XdÒ lP&y¦„ä‡Üdkkk,ä¿´´ÔlRúdÓÀ¸“­ˆ TtݘîLF“¤9==Ý5±¥çOMMuv!^íÎ>ö<¬“ÍÃe>¨B·®*Gy¯½æ-]ªyE^eríããc­¯¯·>=Y_kÁ†›eä”\œ«v„™6wmÞBèÉ~y·õõõ˜ºªêÊQžaÞIJôþúèØØØ¨óóó±ü†G¬\&ÅÉ Áç<ò¾ËËË-÷ɨ”¤B,ñd~FXïf.XÇÇÇ ’š“yVÇIùÄÃÃØVžÜ܉Ö}vv¶K$îììTÕ(¯äææéð%Ïvom­I8´EdEÔÊ\00Ë’–ÍëТú‹¿½½]³³OIÙ¢rXm맪:÷$ÏvÆ$™ZÛú–|Ãü—”úÛ¿ýÛ?055Õ'ÝŠNdU¥ªQYUL:û/ÚäE#///›íý3oEöœs`=ŠŠmoo÷ØÍÎÎv.AÚ'’F(Úÿ<+‚Ýb'TZÊHÙ–õlOÊâ Æ™]¡a¼ÍOãD^—¶˜Ï±·/U=9Ró=µ~DÓΫ.f¼¹¹iYÚ_|ÑëOŸ»[ó|}¼×3˜ÿ.•Ct¢Îj*’}€SLWjÏÉH^$9¥¦Û¦ÐŽÏÎŽN*‡­#ú¬%/ù›´„æÞ32TL ¤ÚŒÍ¨jF¶ °JÉ´frp†}çææøJ»¿¿ïÄЪêŸ ÊÝ+l ¸>£¬U ¡ç¤WÏ|}CN ” èe=~*÷$ÉP …ÌD¨<¡H*ªª¥$§§§5==Ýã7;;ÛU‡ÖÖÖZ2¢*‹þTÉw¬í›››î'?ãp^__×îîn;©9¯ÝœÆ:æðîïï7+oM#_ÈÛè÷§¦¦jss³¶Æ¾Ã¡T%ÊeS"ì ߯ÆF¿ËÒÒRíííÕýý}œœ´<åúúºÏ¨å¦Ñ`ÕONNzÎ8ÒNËØzg6×ZÍdé”Àqb8H^΢õ¢éÅÅE½}û¶XóUnÔdèùú¸®g0ÿ \6½ªQÕ’‡‡‡"Y2íëtuY}#=ýdÝcfsgdªFÌa2Ú’U2²ÊPÑÿbl˜˜"ÿ¸Çùùù1m4ÙÖÌæ€#ùÐ’W}waa¡AP+ö‘Mà,ä èÛô¡þÀ6b$•Îs¼·òk¢›››œg“I–oyy¹û‰óVU×iº1üUõ•šÇÆnccc¬j…¤é,¡IO‰º“zN΀>ð3sS™>Q“µµµ~¦ÍΆ•¥)ÍOsðää¤õ¬6] jÛC>ÓÚ™››«ÓÓÓ lU5»l¾Vä;À·M=þ‹‹‹NÎä,›_À"p͉0·À椓†ÝÌD\—6ƾ dz'ó 0®ªîëÍ|V¬áápTɘ½yó¦e?æ·H§WÔ‚àÜÝÝíÚëûûûµ²²R>|¨åååÚÞÞ®>ô;s(2ñR SÀU¥ ¯Ï™À¾äF¶/O æ däÏSFÒ6ÏsîšßÆc è!§f VÞ`0h xxX O‡éŸŸ×öövGvôËÑÑQžžÖ_|QGGGU5’ôp²ô¿L6Üs9Ê’bõGêáá¡ÛΉ´xoŽoÚW»÷ïß7ˆÀ“–utt4½°ŽƒA÷ÇXÂ;`äEZŒKF7äédÂ-ð®d­r°æ û–¶ÀwÏÏÏ[æÆáa7‘jùH]¼>3¯EÁE _¼xÑû¯ÈHÔdTùùúø®gÍü'p k“K¨H ¼ëw˜%† @Ë*$)UÕ‰aY¹Äó0ÉX?½MVˆ’¬‘3˰Ϥ5à[X5Â@„ö»÷ÌÌLoâYÁÇïUœ™™Õ’fP%Ç%Ó ´x‡¬IŽÕÅ¥V#,ø<¦¸Ê*#™ìH ÌàguŽt‚|?e9 žŒ­g’ùhonÀª%˜E`!Ë>¦ +Çœ“¡iZV¿ ²"Ž6c Ó‘ÓóΦ/QÓ¦‰]š9U56ï«F%@³R“÷ô®@!ðbì50€†½Í~–Óéµ¹ë}¤m™hç¹ØÒò žTP™™™iYÕÅÅE—ĈN¾‚ IDATš÷’ËÖªj ›}Èpé÷©©§3 €™¬8peò²9-QDƺWÏÜ»ä¡P™àoœR*ÁÑæÈE²+$‡qÃÄÏÍŠa²Ä°[l Lm2æ·çrxHG2ÇÀ8`ëììlì$]Œ;‚Âú°&ÙÁ`Ð6ź1·ZÒȆÏÌÌôœŸŸU=³n’•ÏÄScž D“ÙT„Œ}ð uï‚mÏÄZÚõªÑ¡e)Ùa£3œ9"wÆ.#·ßËúî"#È‘nÿÖoÖyUutQûÍ-ûšyi\‘^¹·æZN~ýø¯gfþ¸l©MÍßÙL4Ò°"¹Q+ !y]`U5¨rߪjVÙ=1/˜w÷²)%+dƒ§çˆ±8Œ~ÕH>’eÚ’IpiÃðx/,™Ÿ¶Õ€E²ù¼»»»>4 +BóúuÉ·Æpx/à L­k&N޳¾bàiÔ«ª+Ax'²¤<°D$ I¶ÏfœrP0ö©ë$ ž£/S;š_2Dãšíxùòeƒ‹só‡.ßgRJB6`r|ü1ïRî’•zº~zÎAϸ¾¾®Ï?ÿ¼uÕÛÛÛ-yñìªõ¨qpäu¨ýí½EG”0ЫFÑó2%h½"EàE-0äæUÚ©©©–·¨Æ‘ÕX8ºž«oÉyÌiãc_9lœ<ë”Dî³Ï>«ªê\UµÎß=µ‡£e\2/Â:PY(ç—úÜ××׳@XUµ¿¿ßãn,_¼xÑUMäy(˜¹G¤ )áÈϦ†ël­" €<6éþþ¾öööêññ±Ë>>>Ö‡jnn®^¿~Ý“ñ68 ƈ òðð°?c-Xë¹ÐÌ“®loo÷¼L²ãîî®>|øÐå?s­omm5™`íÓÜëÕf´=É%sËÚ6‡ÌÁ©©©¯0ëlÙŠ:þæƒýðòò²Þ¼y3uö^@½õ "|‰ÅÅÅZ__¯ýýý~¶Ó€I–8à§§§í|÷£££±œ‰”|¾|ùò+‰áUÕι>~¾>ÎëÌ— ƒ¦2å4™\úððTòs‰Ý0”ÅJ|†21‘BÑ<’@ ˆHà¨:©ƒ“à"7šdë±%¹a¸ïÙÙYDŠß‘÷À¦.«8(1©_l‚˜›[éÇÇÇÞÜ«ªÃõ 0–ž‘61}6ý………€ƚܠ”½Ó6YÀfcc£õ¼’q÷Y²NÍôôt—±3¶Æýì쬣¤:§§§UUm,±_@œþP  7Ž=²ÁÑŸøØ¿,ig.£ÌÏÀ´Ñ½NOO×ÁÁAW.Ñ?QãF· ¼9Aµª:‘[‚é`0øŠ&^ûÜ¿jä´ÐÙꇇ‡‡vrèÁ9k±ªšÕ´­—Ì%˜ž~ÒŠsº¬måb±û ÖÌ ÒÑ óˆd~~¾VVVÔz§¸Ô^ÇÑøð¡ËJJìS•Cž‰œ—dI‹¬]€Ó3ô+mx&÷³æçææf'p¦³¿··×¢„â•••ŽÈI‡Ë‰´4îé$Óé|hO‚yΪ¾7l¨Dg‘*ëòââ¢öööêàà f„ÃññqÛ”¼ÏÊÊJ¯I²>N+ÙÎÕÕU—:VÊWt:“úEüD N%‡ß¿_———µ²²Ò'Øf)SŽÃ™äX°1Æ•”qrÞ" œEyLú€ÈÞ`]ÈA@°o"{éÉÉIG Ì)¶øåË—uxxØVJÚnnn:ç“qqÑë‘ʱa6Eaì1Ú3U®hóq_Ï`þ¸ƒdß“ñnTw;ÃÊU£Òˆil(™ÑébÈ݇V=«æ$‹(ÒF,KN"ôœ5¢z sÇkë~ÎÞmä6ý ‹sH;€ À §Ï2ú`s×ï/^¼h ŒÃÄc»0M®Ô‘ú3K ûØ(Ìš~Æò ‡Ã1;–‹3öððTw?+x¼€ƒä3@¨©E0lÈæ þzªFÒ,¿³ùrh÷3úbÌÕxÖ·Yý«¿ŒnþÐ477W»»»Ý>›f²Ãœ<ýQ N `T¦#;>Õ'¸¿¿¯ÝÝÝàú@ÍSfê³Ô™“*™«J3ÇĽÌyÆeRú#ñ¨KûmNI@Ï$Qcȹð}ŽŒ„ÄápX{{{-= ;H'ÊûéKŽ{‚Ç\Ãá°<€î{jòëwý t‘jeߊ~˜æ6g]xûömÏ 7}sæ<°ì—s>ªªÞ¼ySÃá°ŽŽŽÚVI7/8/mŽ §‹†:ÙõãÊÊJ÷;7;;ÛöK%–<Ûj-dŽB曈ά®®ÖÜÜ\ÙÓoûÛc‡›%¹Ä†Z_Nï•÷`.ommµ.ž´*ׇ:øÖWUO‘¹!÷÷÷íØX«"Æ›››mÏSF¨¯®®êøø¸¶¶¶ºrX~–Ý³ÖØ!Ÿ±Ænoo›hš<‰¼êé´eßÖý_TÀšDtˆš?_çõ æ?‹QMÔ(¤Ü Øø\Þk„ ’K²“×}«Fa@† ›|–-Á¸ïåÿ'ÁoÖÎï$ËÎОdñ±$Ùf}ÑßêCŸË°·{è ›‘Mßw8/À|^鈇®¬Å­¯rœ0>ÞÑFbÓÄcó=óù£”!»|OýlcáÞëÌ—¸2“Œ$ãˆgr%J•fTRƒjsÅØ’?UÕÌŽìût.RçˆUÉC:’mʺЖ€U’«´ÅûzyB–@LЊzùòe‡v×××›™òÝÚ¤%Ø'‚MÖÆZ5JäͰ»Ð’xYU­iV©@ËZõ@½ –ž8e'À,0¿±±ÑLªŸMÖŸtÆ´_X8õÞ6<ŽÀÉ‘öLÏ‘DWUÍê-//·¤ Í0t³³³uzzÚm&ȱ֧À8Žýæ9'ë%Ôx`$±Öýr²üžc.'èÁ¨JèÌþ5DR6ãsÊ:,†ƒåX9¦§§§ý»ªªƒƒƒšŸŸïÄÖGÆHËõ)7#$‰€dîÙG[“õüÑýQ ‡ÃúéOÚó†tË8ƒÚÝÝ­©©©±C9´yÂÖÖVçX©áÿþ}¯] 6Yæµµµzÿþ}3š[kAôÊ:b»T²Rò‘ƒ9==]ŸþymmmuE’\;äc¥ OûN΋/zLÙ csvvVçç篓‘!ãC²á½8TÈ‹ÙÙÙ.ÛXõº:@)ÚÔ›kÏd‰ÏùùQxë.˶NFûŒcæl)­ëy™„NfyuuUggg}Ú,[$ªÀØ\}#ÿIûíäTRÊããã¶)lÖp8l ­ÝäA œ±ñoÞ¼©/¿ü²ž¬»ÈŒü R"2Löøè討k}}}¬|¯½&í±(«ý:‰šçë㻞Áü'p1H؈ªQU…¬ÓN£š™øÀ /ô™º{‚Ô‹ÊÐÇŠ¤ ˜%ïüÜýÇ$ ÀÔÙÙYmnnö;$S{ttÔb%Ól”Ú=›4¸éPTJðUÊHú=ð’'}r„‰…EÔf_\\¬ƒƒƒîKy UÕÑíòn’,1zU5f¸É’l`ô¬>c3ÏqÃ0ù®²×××Í׳”î«· Ù“@´æI:¥ÞÝeæH.~Î’YÕÇ|BDbnook{{»NOO¿R‘‰þ»ªjgg§ŽÛ™°I¥8À à™l´JŽßp8¬7oÞŒ9MÆ\ßœžžÖÜÜ\Ë(\y¨ÇмmšŒ™?)H¹ ÇVÄãòò²¥1æ ýò‹/ê³Ï>«ï|ç;uqqQ?ýéO{'#>ÆÓÍ‘Ê$x}ussÓ3'¨›žž®äÓÓÓuttÔvf¿gïù@\$s›ó•“­o€Ë‡‡‡ÚÚÚj)âââb­®®6# ÈIîö÷÷{ÜÈtLæææêðð°×ILUõÙ®ÙÙÙ>œX•J‹ÏÉC‰fffêõë×mÓS¢…„ 9É¢iwwwc‡üɉ"eáôëH²+éQÕÓy™‹ƒ8>>î\ζ›Ó›Q“Œ.žŸŸ×ÆÆF·cýððÐI»ªiqn÷ööêÕ«W ¼9Ù“¥˜½ÛbŒ8,³³³uxxØë“m»¾?µØ½bÆÝ»°yIV™#œ¹çë㽞Áü'pÙ˜“=Ã$¸0S“å'mÄ@©ÅæV5bfƃáJvñlF ¦(Œ ¨{û?ý®gcjÜR5Âï²]¢÷ ›„(A†0AŒöd2ï ¬Òtº0TU_ ý§f¹jTß>ÛkãÌdâÙÙ'ý®²›œ0Àm#ðžXÖÔìÒo'+Ω%´f•#QÉbU£DKã‰Ý80¯~Ï ä´q4ÍÑ €«’r DSŠÙ=99©™™™1¦¶ªx§” ómÜE-0x€"†[+¯BŸjæVV-É$që$çvÜÚêž™Àû‹_ü¢ÇI|>çT&Çš—···cL;@ì{ú)åCÖþäI¹¾£ŸÍÉápØÎÒÔÔTG˜Èþæoþ¦¢ÃE̲ ÀS2¶Þ'uæ"mÚx²'Ö»*6¹žÌ/ËZÏ>É9hNÒÉg¤&çræŒøÿÉÉI×çˆÉ×yxxh}“UÁ\˜uo:Ä@69‘ÄjmåMFb8½™°­Ä"›×òòr;."rYÒiE°5Øh},ZÄÖ³%‘ãø?ÉŠ5âÀ¥™™™v~]Æ ‘{[²äÖ~UõX\]]užNJN9}ìÈ‹/ÚX^^îäTÀÜþ„xÒ>íâœÈyrZ–Ò­“{°H'ÂgRºù|}\×3˜ÿ.ŒYÕÈÃgt?—¸²²Ò e~‡ÝɺÄ6y¬™ Þ†D_îð#,ŒÍ¨j”ðèû¹A¤±Ú“›Ÿ ÜňVUKe2@˜ð$çt€€Ôåg¿¦.9YjÿWÞ®jtäýåååXb¦S1ÀN” €PåÆ&>==Ý€IŸy߇‡‡:==í ©ê¼&À$;ÈjBÀN¦Sg{yyÙ‡Úˆ0ÙqÈy($OftÚ]‰mX1›# B&™Ç@¨yÌÑ#S1¾ÞɸpzŸù™¬ª9EÛ:==]ëëëc¥ENNNÀs"2b$¤.T œÕââbµ3FR9yJ%‡ (ÓGÚo.bµõŸùùuQ6N‡ÏxÖÀúúz­¯¯WÕ¨ ¥õ»¿¿_ÿú_ÿëfk1× ‡-p’²>¦îïïkkk«Û“9NìtOR @ME :­óôôtmnnÖÉÉI'C´î#¢‘§Á`Ðí0' ¤Ý$\9ØGŽNÎWï˜92ì¶ NUÕÎxæd>Òòòr;ë"°ïÀÖ¥vWý¯i±‡“©ƒÁXBúË—/ëýû÷mêõë×]ýèááétdćR®Øï‡‡‡z÷î]-,,ŒI IDÍe²:ÒGà–½ªåCMMMÕçŸÞUÄ”ÏõŽsssµ¹¹Ù6 ÍæàÑÑQ'!#4¦§§Ç4í"’æ£~wÚ,i”öºô»}.O1&ùÉ*J···-ÌÁÈr¡Ï×Ç{=ƒùOàJÞ&ŒõUG !)Ùʪc»üè`$±u V,«~ø3 :#Ÿ‘ùºÚÖ)­È÷±)’†´ª×Ø@h2±z6EÆÝf ŒÏÒ+ÛØ³J†M²D¥Í,..6(nݳœÚñŒb`â¡”°O™‹Àž`û'6(Î5uuuÕ¶†£z;à]WWW[û¿°°Ðy.Ö g;ÏÑÈiÕèÀ$¶GTóź1—Èã–——»–¹qOÛfnÓ‡‡‡µ¶¶6v`—½ kñË5‘Ó÷kkk­‡]X3Ïæ<&3npEÒ!¼:hIg C˜Ö†œ:ÝÔ{ùNÀ íú¤®šñªò666À3ؘúL`µ0ÈÂݯð«ö$šEªžôæt­ØT@@á ²‚ šïy_ënÒÑbÿÈŸ2‡$¥Z$ž••jü©ªŽ0²"XÞ«ªÚvŠÖHÕìGŠMb7Ø÷“““fÜ•D™ŸGGG-Sñ~Þ‡}4—677¿RúÕš$­3–æºuo}cí2Þì®ýbii©Þ¿?–§Âö[ÿæ¡ Z¤gúdccclOf/«FQ’ŒŽßÞÞöYXX¨?üÃ?¬çëã»~ò“ŸÔszó'pa„3\žà+Au²P¾ê'Bü˜lm†¢‡Ã§ã®“Áö]’ŒL•³³³1™‹ïi[U5[ëù"]7’Þ_h–‘’›:ò †^ºªðÀphCÕˆÙ¬ª®LÞL–#ü*¤^UÍJ wbæRÊ’÷Ð%Él¨Éú(÷†Mó¬äÉÉI38×××uzz:ƼêG%VÓÁO6:óDU mÓBöXKNøYD#5¼æ”q—`hl0{äGwwwu||ÜlŸTì¨ Ú¦—Ì”$< £.²! ¯333Ýo>—Q IÄd>ä ˜Rsüôô´žªl`ûiÍÉä'`Ë×ÖÖZR´½½Ýsÿêêªåªšhf HŽ•R3l¢Ä:Ìâýý}šDòlîííõxˆ„dº9?55U§§§-ébC2’!Ò–§ÓZÓt‹Øˆü¹×ÆÆFGð”‰U>—Þ=õÈldœ...jss³fffjoo¯íW& ½¢7{k”ÌÚù°&µ[ßI˜³1½óÍÍSiÌõõõ.u©ÈXRе°°Ð¥8Ù@zõ”>U=IUHšD åWä¹¢^;;;õóŸÿ|lž—´îµ½½]õþýû1}6yZUu‚Üä…ÈÌÑ“,Ž€ÏC”°ñ@6§Üúe»Ó¦NJjfŽdD’í¶ŽŽŽÆ¤Y¡ÑŸ¢f»’Ì µ¾¾^Ãá°Ç"[ÎYHyª½hjjªNNNÚù"íÔ¿¢ÞInˆ—¨Íóõñ^Ï`þ¸ à)eYb~~¾kQg"(Í»p2ƒšŒ»4%ÂÚà9>£ìÚÆÆFžž60 uJžh‡ šIO®t ÒÁ¨ªÞ«ª eÊwƒAmnnޱï@WjÂ'ŸCÏ ¨ÍÏϷγjbÖçY B(œn?kÌ;™²jTу°³³ó&9O}ÊÆÖ‘"éÛ ‹'ãñª§Ìt¾<߆à H]q&HJðL©‰û âÆ45ÿŽ9 %<Šx¾dCðE®¢4"™Õ$H´€K̺ä[ '¥6Vï5 @0™ƒ‘sg~~~,5+¢ÐÉêŸdç´9y¢8;ðôôt—õ›ŸŸ¯÷ïßUZ2oHÔë7?õåååeHÄ©¥ßÛÛkGÈ»ùw:·ÖŠd=ßá@æÉ¤€&©Ø`|MýÆ p¥Ý©ªÚÚÚ_Zé›››.…ä:¹•]"匭 clü­‹ýýý~¯õõõ~OR(ÿÖžt3:%Ùݹ Y V³ÛÈ ’šŒD±k*$ÌÊÊJíîîÖÏþ󺸸蒷Úxww×6‹MÖ·»»»í¼¤‡]†•C 4îÌÌè”Rkœ#¯ma}@Ö633Ó\£ÅÅÅ1‰(Ç‘mHÅÆxžµÈQó®I”X¿Ö>P?Û(`>xOûÙååe'†§]!•@Ìîs®Í%mà˜ŸõZñŒŠIœ}¾>ÞëÌ/}vv¶“«...4,˜›Àââbžž¶«F§«bÖmÊ 0 TUý»õõõÞdU$xxxh9 –ryy¹5Þ@ öW5À0ö¾Çˆ9ʨÈ$2 tqqQÛÛÛ]Ú,šÕd€.`4#س¬^¢]ª³Ð¶Ú02âÁIɨèÅ‹urrÒ}£¿&¥/æg[tÐX©bbnaF9†  \Ýv`Šƒ³¼¼\‹‹‹urrÒчª'¹xFH¾üòËš™™i;“ n{{»sIÈfªF'¤bìÀ`0¨éé§ê&…Œh~ùå—1¡m–w1==ÝN…œ¹À,À—IûúPæ¬ìííÕëׯÛ&dTvÛڟʉ ì“õÌAV‘JR­{ŽÃá°vww{mú9û:í5žûûû])É€ªjí?ðï„è………ÚÙÙ©Á`Poß¾í{O®Í‡upp0VÚ”ƒËŽ#bŒ3!ó—ì§+ÒcÏy²ÎžêØ[ÇsssõîÝ»ÎE¥ôL£Ìm0ïgggëïþîïÆöeûÇp8ìèÕôôt½zõªž¯÷zóŸÀ•!ñ”:Øì€W5^·Û=°MÝÉúÜU5¶!g˜ÌŽ„´¬R5r€’¼'†'7}ÀC5l&Cäbõr“Èä/É¢˜1 @…].´Gµ—ªêï’©T€8 ™åÉQ@èïªcQõ•÷žžîúÎ@ –3•v:iޝ{è¢ÞàL'‡“¥Ÿ0ÿ™ìèP…\†´#™ø|OÏÎ’Š>“’ÀBdðÍù”„¥d,çt®‘¬â¡ŸÞëÌV cx,t¬MÎU™ÔWfœ<µT;許«’Gj1ÊXÌ(YâfˆÉFù/›¶ËÅP2–˜.šÈ”µA3ÈŒ$ ìóJ÷››ë÷J`-©IÅ–ÔÖŠV+ظ´ƒF „5Âô‘èT€µM䛟:^]ŸÙT“ý²áùÃá°Ç˜ôÞUÕ ,I]òÔÔÔ˜lDetœ®®®º=™KÞÀ±0‡µ˜.ÎÖÚÚÚØ¹¸j!´éúç3Öˆ:î´ér:ÌssÌX€“yU5:}0×v B€F×z4oõSVéÁ6«ÖáÉÉIË»nnn:F̱Ð~cp’‡ Çë{kÓ<÷3÷å\$:==Ý -…H¹—ù$b(ÕÖÖV·0ã4dYV‰è"X™,‹Y¥éæ”øð¡óØ,vÀ¼åô¸oÚó›}vvÖl¯y˜®¬¬ÔÑÑQÝÞÞÖ«W¯ºYYÉØ“xpÀonnj0ôÙ 777m§8ˆ ºxöJÄH´F{îïŸJG*Ï( @•ÁRÏÏÏ×ááak½«F‡”­®®6‹/A”“"Y—óêlQ’´€ýþþ~-//×7¿ùÍúì³Ï:ò€8H²)£/öó™An”ƒupvvVoÞ¼iF]’íÕÕUG†gN[’:œôÕÕÕŽNÙWõ³õl¿¹ð½ápX¿úÕ¯Ú†ØßÌ ëŸVÔíêꪻoÎË{ñâEï…/_¾¬µµµ±SpŸ¯ïzóŸÀEÖ$ëÅÈX´§É83š6óÔÕÚܰá6BUõ¦CÃÊX‘5`B„ ±,˜|ìïüü|ýÇÿõg¿ö=þäð+?{ó?~ÖN VWHO&@;<;;;V3™|GøÓxppÐɬóóócIq)ãÐO€—„YÈÆÆFlŒŒ¾LÖÅøJ,åˆ%ÛmI=·q¯ªf+S—o¾¤S ®ùb(=/™uÀÅ¡RaFY$¤©ÌBŠ`<õ; †ý.8‡Ê}ÚŒSžUUý9¥RÉ/›= ‘8 ½ÿ¾AÜôô“F;ëx{mÉç`9†@—š¤Ã8mmm5MG”Ûjí“ >)Ȫ€iÊÛ8¢Æÿ°0ª¾±±ÑÀ™S@vBª’‘$vB Ð×.}ÂAœÈê>|øP···µ¶¶ÖZìÁ`ÐIìæ¬~±ö¬i›¨Šëüü¼vvvêööv,çææéR‰ßsssu~~^GGGí€$Ãî3æVÕ“t È·² fJ­0éþ/y#Å9@dh#­?[›i—ý­­­&Zò³¢ª™'±°°Ð’2m¶ž%ÝfÕŸüÞÆÆFmmmÕÝÝ]Ïe$€g¶l‡ÚüìÐáááX¤—­áÜs$³<©5Y!À5¯kcc£ÎÎÎêýû÷]÷Þ~e +kl?›ŸŸ¯½½½º»»ë›"?)5’ÔÌÆpìÌUdÙëׯ۹co§§§[Âgá͹ý|}|×3˜ÿD®”§0þ60yJp„mºU#iû‘¯ø?€ŠH0/ÆÎ휖333„äþ_wù¹wœÔi§´†#”̬߹ò³¬0gK ¡o|_ÿä•%ÿ«ª«/^5­žŸs"¥: c@³šI‚ ô«j,úá¼mæD²žo¾¤Á30䮜Ÿþ¦‡~7·€Cß˶¦|Ë;ꋪ§òŒGGGc2#:YÆ6O'­ª1à‘õpB8hYí‡<Ë€&ðôæ2§Ñű$ÀPš“%Í ï‘ÿÏù‘'nš‹æ‡Õ3µ1E%êÀ sïYænží$s­U=é߃AX,¾qÓF&•nܸT§?Ç.ŸoÍy®¿'/ø"ý?¡o8íÖDÊÝbŽëd¾Š1˜´µîw}}ÝÎT–kõ™Ô˜³ãÀ»µ$ᕞnnn¬o¿îýU@Òêæk3‡ÌؘÛ"Ö‚Jk¤Bæ_ÚÁ< )ËxnmmI§ÒóþÚ>I$݈Γñæ8dÙKs)å”)Aªí{ò_”¬äØ¿zõªNNNÚ.8œ*å…Úk½¦-´EØgc˜ÑÛçë㼞Áü'pÙˆz›¬ÐJn0™ëçY"<"í†Æàø½K¸>u÷yÇäÿ«ª«°Hü©ª1öææb@µÅïÉQRs;;T9e˜…”ý؉€U£ †„3廨H¡f¬šöú¬Ò›\SÏ­Ï û"ø!99::jv Ó{qqÑIÀ~–UNŽŽŽ:i6Á –šX›aêEkË$Cé€/‘UF”Á³éù^†×>M‚,¦4£?Xs\›“¹ÐÚ:)Á0ðîî®vvvZ»´´ÔÉ…Dlðc­qdÖ××{ƒöÍ×dœIÜ+ÿŒ QYP A¹:!|à‰Ü ¸"±0Í%€S›¦¦¦êÛßþv}þùçõ·û·õÅ_tâjFµúdKÀö¾———}”=g ë^¾|ÙÚpk¤hmm­¢ª§dI‘kb²ü£¼†,[Hv±¶¶Ö‘@}©>ûÝÝSYT¹$’_Í+ß{õêUÏgmÁ [ÿNÑMÖ4£€.}v~~>–É:”èøøx pÎÎÎvä@d Ó½µµÕ6»ÌF‰ºvIG¿C$yãÝÏÎÎ:ñœC+©4óŒÒF †ìCÞ›lÄxe¤÷êêªvvvº'^¨ûvÍû.//wt:åwUUÇiËoß¾­ííí1§T)QvÒ9›››Í¦›_‡‡‡=nl) pýêÕ«¶#ò`ŽŽŽzýësLD ÌiÉömÄ ©PV#{¾>ÞëÌPçbôªÆ“²Ò©àé{¾YçÛõððÐÇg“ ÀhV$aÀm@ŒjUµN0e6 ë'Ë‚•ÈïæûÚt³Ò ¦ðÀL1ÈÀf–+Ë{y·ååå±(‡Ÿ“$`s±;&ÖÿÀªÈÅÝÝ]W‘Áš“K¨ï»j­{_϶¡W}õ`§ªƒjü„z³ê ¨Ì~ÏyÀ)´AÓÃŽ$)UÕU:€›.póçþïí|þÞ÷¾ßóc²BÑÃÃCµ´PD‹-gC$¿b¡ÍÜ«¬µÍÍÍvzØ%`˜s`ݯ®®Öw¾ó®ä2Ž*gÝÜÜÔñññXÿ¯¯¯ES‘õúõë¾?)âúúzëÑÓîÉÙ²Ö­[óËøØ§ì#Y¢T“.--Õ`0³Áé`žž~¥J bHĘÓ÷ë"ÏÏ×Çq=ƒùOàšýJ¸=àIÔ®3l=p `ëëëͦ¥Æ¿ªº‰°®ãÈMpJÍq‚6ɉ‘ö:XLJ‡‡~¥ H•xi\Èj|Æ»›BÿØ&5Ÿ§§§{Œl¤Xo µp6 Ç™ÚØØèû&(t*ÊýmjàùùùZ]]+hc:99éþ'EI'I?*¯ùþýûš››«Ÿÿü)'â{ßû~oˆ´¶*[üÅ_üU†s— ™+ëëëÝOYÚÀÈ$Içååeç—p>8n¢OôÙ@ÓÎÎN³×)ÕÑO‡‡‡]ïÝæLB¥=Íéd–­‹,IXU½A“èg š´ÍØPæ+pà3Ù{ïââþ‡ÿðêêêª~úÓŸÖÁÁA¡þ´¾´ÙZ™™y*‹ÑLÝååeíîîÖêêêpÂäj‹C…ÎÏÏkee¥z‰ºtÑ4逛“,pJgff¤UU¯õËÙœzxx*ƒÈAÅÀÊc1NU£ó<8ïì”ñÍ(Ìââb¶,BB);º½½Ýã„ȃîäÚ 3ëää¤+¶O4éêêªvwwÇ’õ'“·%B¯­­u$âîîéP®W¯^µmQ‘É}3bÊï!>ØÎÏ>û¬&g€“¡Ÿ8 mÛçççÇ"lËòòrý½¿÷÷ê·~ë·êßý»×s/£L¢hNz}ÿþýXIã•••v*>|ø0Vþ•ó”ÒKÏϳ<äd® ÇÑž¢v|žÛ"š&ÿG”Wd‚ƒ˜rÆÙÙÙ:88è3b¬sŽ({aþ=_çõ<ºŸÀ•ò‹{ ~3(ÙëdðmÉàò1 <>Æ}U€Ià·a#™TUc›d2ñ6`W²|žë³þ¦¯Å0j‹ê36` (ðmHæD˜ÝéÂðÀ|UµÓ÷R àè'¬ljOó}lð©¡Ì’„ &1©‚çiƒ¾´Ò1L}6yPÞ ¨t¯Iù ð7ó×UUõ÷ÿþïþ'ð9ly•ˆ‰þøþ÷PUUõWO þ÷~ïGÝ^r ÿž,‰—2 ¡ªÆ–}ï'J1éHæ}³¥ße‰O€™\Æ5OųAç³s~p¸«Æ«û`ƒÁXrºyt¥Ón›'~/"÷öíÛº½½­“““±\áp8ÆvzТ¿s¤SœQ+`:åj¹žÌч‡‡±y¤Èˆdê­ÛÂúžü Ëè@É!ÆÆàÊA¦ÜŒNÝú²n<;#‹Ú5y6 ˜å|¥ž£]úÜ8ˆ¢qÚ’ŽNÎcó-mÇ¢êÉé¢Kg“I¡R>•E¬Û¬´µ´´4 ©ª–×!2Â(a:³3¿ÁZG¦HR_[[ëDZgÎË”ûˆxd?XæLÊ7Ùx{QF6éøz;ÃÙB|LÊÌ RÎdÜ2gA¤y¥Î*ZÏ×Ç{=ƒùOàJ œJnMÎ(Ú@± YP"Ÿ*ôd8 @dj’ IÕ(!—ìèLM#–Ç%¾K¿:ë›ÿÓç57Wc5x±U6Â<('õýþÖWŒVÓghU_¾|Ùì Ò¤Fµ>UÎLòX†ã}N»¶¶¶jjjª£N8¬ªf]îÔãŠ|`CI24U5¦Õ_ZZªóóóCïfìh8=771ž!dh0Ôââbo¶™ËðâÅ‹úë¿~:2þ·~ë·ÿ“&wtàÔd¥Åææf]__×÷¿ÿƒZYY©?ýÓŸÖïýÞªê‰E”hè]Ó¡¬ª®""±/«<<©jT2ã.ÒÃ)À.//ׇjnn®hÖ××ëË/¿ìM–.W‚ê"@š²¢3»½½íñÀþq,ëáá¡666ÚQ´ÑÓþAæBÕ耵Á`Pkkk#¢o¬W¹*q D[D«¬Y6Áœá lnnö½°¿ÝWWWk0Ô‡Zš}¬z‰YÆ•–Ýx¨œ“ce\µÏúã0|ãßèj:ÓÓÓMjœœœÔææf>¥3úFYZà_‘8¥}jjª¶¶¶ZWíù×××õêÕ«Ù©ÖNëS‹ôâÅ‹omJ'R>Ñëׯ{Ì=ãL¦"b=Æœs°ù+++µ¸¸ØcžÉð¢p¢=$E×××]þHO`-J`þʈžpbD*­„ÁíímÏaQ¸ùùù:::ª½½½zÿþ}½ÿ~ÌyÓ™—±°°ÐQ÷b'åïkÀ>«Ä°Q™·ã¹òD ¤gUÕã b®ä$²‡C#ªÇ¹™™™é"ª#‘JéÓ´¢vÏ×ÇyÍüñÿñ?ùâ‹/êÇ?þñí¶<_ÿ…®þÏÿy'/ÑP3F™¬ƒÉµ)ûô¶Œ+à–‰ª H‚˜dÁò@›r:™ÈwuuÕL juuµË:r míJ (´iú\žbˆMª%Û%g¬±ŒX\›ÃpøTùs(”YÙ£ƒ=ÓO···õû¿ÿûõ;¿ó;õË_þ²Ãõîãˆr÷• i õ¹Ð>gø`9wÉH8?XÎóóóɼ©í`&ûkî[` ê (þå_þE}ÿû?¨ÿ½7cƒi²Y~Ø=ÎÅÙÙY}þù¿¬?û³ŸÖçŸÿËfÔªª%Gßýîwëw÷w[BÃùùÖ·¾Uc•„Ì9!pò‰ååå–’X˜ãÜdPò¹¤'U#öÜ|·¶„×9„é¨ùL2ž«««cQóÈü\YYéÒ¦+++ ²s¬È¾$áb âj=8Iõøøx,‚gnkkk â¸csÙ ë³®½Ø|àVú9À»²²ÒNºu(qõ—uYUcNM2óÆÂ©¦Ö™™™ÖvK̾¹¹ézþN’ÕsÇ:Jv°ËÄhöȉ©ÖÈp8lPùêÕ«ŽNfµãùÙgŸµ=¥õNiœq´6µ¥ªZ¾‘€yii©žòŸkww·êøø¸mQFs³Š 0«3¯jzzTs=¥V)5ÓgÖV&γiÓróÀ~ûöm·„%«F‘ãTUíîîvÿØ×Ø•©©©ÚÙÙ©‹‹‹:==íºømÙÚÚ+çlý!+ØÒõõõî/mÔçlF1"W؇”ij;â'÷U{ˆHcUÕ?þÇÿøÿ *<_ÿ^?ùÉOž™ùOá"dä]¬« HW›€ fX$´¥dÃß =Cí3"J-/0¬'+‰‰³¡Û|"¥î€ì“ €Ub«ÃAªªåU#öRx•ü%“7m.@ Íñd’/ƒ ˜©:ruuU¯^½j½·’nÞifff¬}_'JðþâÅ‹ Í\®¯¯7ûy{{[[[[ àÔœ¶©f"6ÉXci:SË Ä—ÍÄ›GtË4äí_ýÕ_Ö~ðÚ™%sÚ¤åeØìªªÕY\@â÷¾÷ýúÉOþª~ô£ÿ¾Y)rˆðþAUUýìg?ëê˜Òªêj ê‚W7vð2Ÿ’­7dXúk{{»é»»»®|Áñðž€(‡¬ªšéã˜qª¬€?+aVõ‘¾4æñ Èr€0" û ‰õ7÷­1¼FšäçpTÌ@2¥iÖ¤¼‰¹¹§C¥ô?‡ß|½¾¾n†œƒ” dšéééÖÙcô­móÍùíÔ§›×óó󵿿ßD‰¹Ÿ ,y ð'BIe\KŽ&:syÛ‡‡‡zûöm™¬,y:™cQÂŒZ¿ä‚èÏ>û¬×áùùy³ßæ©9h>ØSD¬Îv+™Éiñn™“Âaà ›oúÌI9¡=É<qáôlmmUÕS²uG£:ÐÙÙYíììô¾uppÐ0áö©ªª>t4ÃüË…h39§Í»¿¿¯ÍÍÍv¨2¯‹'93çÌ[ŽŽ}”“g\ØwÄÌóõq_Ï`þ¸RFðu¥ÏH>2Ipò’r0®Lr«i“«Fa^†F-Ì:©M^~7©Îj,“ÚÓ|_!÷NrUo@ÎF•I¸¾“lvêp1e)˜¬ Ãá°™\íÅFWU}ñÅ-urì`Bý;Ç û=ž wéÀM¶3¨þÕ©)n…Ñ9P¹åß9^?ûÙ¬üà‡=ÿÜß;cÙ´ì_ sVvéùÞ÷¾_?ýé_Õw¾óݱùðóŸÿ¼ƒA¶Œ XM9××Õî×nàŽS‘y€SæÐûªL”eö|Æ{åÜL-qŽgÓ}R†]͵mŒS:‘:uz᜞…mx•m|.Çn0tÏFSœ‘ŠªQ¾HÕ(Æ{JÀÄæ{/Žƒ¾xñâEW2¾™è ¤ÎÎζóœ@ùøøxì<szii©“¨µ]™Z}ižæšíH™K&$êOö'm«Ÿc„­!v‰Á)'±â$IÐμ„”±S~' ãX!rD÷2B[U‘qú-û“ý _rðó´•cÅ6…úÎäÜÎuìóìBÚ—b÷÷÷cõöÓñ"{Cl{¹úÌXfÄ’Åfù6«žõæÍ›.!éÝ-¹NELò½'mx&Ó³)“ë|r_z¾>®ëÌ"—…Œ‘ËÄØ„¥¥¥:>>nf\¢˜qª9Xó©©©Öña•°X6 Ësmš kee¥ r–"sïÜPmüX? @”ò’,¯¦ä&p`ôóÝÝOY½‚˜×”’\^^63ç»´ü6‡Ü\$Ñýâ¿èºÖÓÓÓ­SµQ ‘Ûü3ëìì¬^¿~]³³³­“Ô·˜B}’ ¸wÍ„/›ÖÕf— wU#6Z¸;OiL8¥¿üË¿¨ï~÷·jjj¡AâÙÙY÷ ½4VµªÆÆ •:áLòúýßÿêOÿô¯ëw~çï·DâßþÛ[Ãá°õ½››› Tfffjgg§A-ç®ê‰-?88¨ª' o£O™‹D¶ÌH'#5à€V1O¶•,k^¥ã¥rJêôÝÓ¼ó™tôOJ38ìÆÄgÌ-¥,E¾èÆÍGÍ8-.Ðk½’¾lnn6œ •ÞÅ|ÉòÌQÌ"'ƒ´»»ÛÑ ©@L4Æá´æ½/@è¤À®aƒ±ÎÖŽ3ÇÇÇ]âs8vÛÌ òôA:˪*½xñ¢Û!Ô×úucc£fff:FZ¯*ždÔÐËwßÝÝm»*"£ I¤äŽ$tǼXZZªýýýŽÞä<äD›oƒÁ nnnúÔbQ¡ŒV°½"< rÙ)6Xÿä•ÕÒªjì.kˆÇ‘QþR4`mm­m‡ØóÅ)ccÙ¾ŒÐØUµ™éË5,Ï%“ž9A÷÷÷u~~^µ²²Rý×ݹ7ÊãnllÔññq¿Ïóõq_Ï`þ¸hWK]¸˜A¿ººªËËË; Jü¤OÄ>Ø 2Á [•,?6ƒ1·i3È~FöÃQ Op$W<ë33†Œy m£»ªQå…,m†9¯±ÂÚ™,ËÐê1“Ÿj ÖgRKls¤áNé =-/9¥>4àÆ€ú.y’Ä®,‘Iú°˜/Æ×º¾¾^ïÞ½“=щ&[e#ÎzÊWWWõ·û7õÃþN]_ä3Úå0&÷ÌrƒÀk …¥S $føŸc Taúô!†-¼ñÌù\ª¦Z`iˆ•S$Ö›”}$ò"Jsß=|¸®zb½1÷œ+6#ס¿“­5¶tùÈ å9E;´Åe9¬’)Ù#ïH§ÐçÆfii©ÖÖÖê7~ã7êóÏ?¯Ç›››±Ò“r} åÞé=;;kçqss³ó¨Øοv"ŽÌcÑŒ¯³·ú­ÊÄÙ,Ñ)ñœ]õLuÜõídYGäŒ$Vïç¾Öµ¾›<:ízJ |—¡ÏºUVÅáÜhcN¥-ò³ü~îå³³O§g’ðóõq^ÏÌü'ÜÁœ IDATpG˜a·ÔVUƒ¬XDF„‘"‹Hy#Ũ¤vðññéFÛ³´o²äŸ › 4H€(Ì'Äw±Ùîˆ`Có¤ÛééÑHXà ›bˆ„™R€T5‹)€‚çbø1£ ú3Îq®RB0;;ÛÎvÕ˜j' €yÅäøyj¾onž£’ä‹á•<–I…äBæVÒŸLìʽ½­_þòõýïÿ noGV:YŠ #‡ùSE‚Æyfîïï[‘R ì÷d¢$ §¿±|Ò›ÙÙÙ:>>n†¯jtB1€â]ESƒAÿ,@è>ÇùùyÏó7%/[ÕDˆ ÇWWWµ¹¹Ùs,A9ÐRõ$wQ)СÂþJ’ϳ°{Ö™Hƒw3÷.//ë³Ï>k–ÄâÕ«Wµ··×Ï£ûÆD?<<4ã¨ç\ÀtŽ———µ¶¶ÖíË’u“ÉçÓÓOÕT>ÿüó1pŠž°M«««c 5`X’˜™3¤ ØwQÖÖÖÚFUUÛˆÌЇÞ;88h-vê®WVVj0teÉ“lóÃÓP*ù¡(×`0h'óèè¨~üã×·¾õ­>­ªêW¿úUÛq%†BZõ$Wq®ö(­h~X·éÓèçÁf¤YìWV¨å½½¯©T%ŽÚDi———;Z{ssÓ²À§~oo¯×¿¨( û`¦„æàà`L§âS:X"[WWWí²'¢§§§533ÓN¾µ±ººZM’p‚<ËÚ©µ/‹&...ö¡v"YÏ×Ç{=—¦ü®úOÿi3bUÕlSJD€å %ý‘0$+Žéò²äÆ%u“ËË˽±acR§šÒ 8Ç. ÿ›Œln’Bì6›*ð4ÓVUë³×ÖÖ¸Ú`sÃÇì¿ i“!e2œï%[ÏÁÑ?ù<áZ,$Mö¹RkÆŠóÂÉòo2"%äôYVÊ÷³Iù¶Ÿ"¦óóó®Q¯ÉlâæÁÏþ³úÎw¾;¦KöÞ>KK¸ªR¡Ÿ€Âd…¼…¨ÒùùùúÆ7þÏú7ÿæÿªííÿ£å%6ÔMŽ—ß@Š4ļpºí$“>==ÝÉÕªM`àÓ²öô…¹©—ìnV…ªzrT©ªvV0Ê©»MVîèè¨^¼xÑ¥NTN¹ïÒ›sN>|øÐ KŸ§ƒ¤ºÆååå˜:¥YœkUp°©Àç™/"C¤%€¡ñ÷ޤKÖ,Í}–6Lg—“ë9§§§cù/YÕˆX°¦9éÈX›ÞÅØ[ËdpòjmŽ·ê(ÚIÆDZ(±8+ÝÜÜÔööv÷{༗¤XQ}ÿþýûú»¿û»úÕ¯~ÕÊÃÃCç<<´–?£Nçççµ¹¹ÙL&í?'K©jT$ÕbÏõNoŒ©s¿<ÝSb$àg,onnêǵ»»Û¹ œ9ÂÙÎuºººÚ ±œÍÍÍ^×w‘ÿO&qss³×Äîîn½|ù²ZæÇÔG½­­­:::ªíííZ]]­ªêw÷nYbÖ™ ÚÆ!É2”Þ›£Å¡Èƒy.//Û–¬¯¯×ÁÁAþööé+õë±ÅlÓÚÚÚ˜DŒÍIYIUuîÈõõuŸŸ7h¶${/,,ÔÖÖV'CrBîîîêW¿úUŸŸ×ÞÞ^ÖÙÙY]\\tÔÈ=88¨ÍÍÍÞ$ÉÞÝÝ5Û/‹ã›Ò*v8Ö_|ÑR™­­­Ç䈸©ÓnžêCÑ!ãg/B¼¤]ÖÎ".ÒqssS;;;cmÍι*ÂÌž=<<´ö_a‡Ì3á$rl8™×•ºïc?´g;÷Â|A²Üßß×›7oêÍ›7õ½ï}¯ë2Ý“]y¾>ÎëÌã^Ucuw]­‹Á°ñæØɺ’Iô̼Ðæwò»’‰<‡ÌÁ=¸,ÝÆ8cumä–<îÅ~][<3æ3\€Ó¼o–Ôf 'åDîÁYÑÂÖÚOæà÷Êšaœ²ÏScšm׆<3ÇÖfBKìßNFUR㚥<«ÆË;jƒœ R¯ÔÎÛ|ÓqèÉœ—½½½~'ë‹/^4è5®úšB—LÚ}ÌïM:’é¨ú;縱‰™˜ï¥1p“ã”uÑEÊ´AûŒ @›åî’­iñLŽ_Ö}ÏKd$ç¾1ËùÊiøºòžæk^žÇ¹À”š ÉàHÑs§SZúëëëÚÝÝ­ÙÙ§dp÷Íy‘r, 9kËgÿeù¿÷Þ˜sý¤oRö797´ß:¢Û–ˆÊÎfÂn®}¶@b«{’ûgsüøø¸ÿ­Êéû:/ƒ-0ÿr]éÑ2ïãà´üÌäz7çôS–´ Hû+©=ÏZ±Oqü«ª‰}1¹VÍqýg'çëÜÜ\·WûÙž,`]¥–‡‹MÚß|ŽûšOÆŒÝÒ^{„9dŸ³WßÜÜôçÙ±œk“òÕçë㻞Áü'pa<èååå6ìÀ³ª)Pîm04 uU5”,4ãŸfbË¡` óJ´s²üÃÃ(Y5e;“lžœ€d‘ÜÊj X £d)ŒË`0¨ªøÆ^©/B`cbd›aº¼¼ìMÏ¥Ž»¿0xggg²®ªÖVKŽ"i —¦ÕåàTUK†Ãak€m'–kmmmL7EÌÀôöö¶ àÈJ¹…ù†IxÌ=g0lÉ> Åg j‡T©Ér™‹é ƒŽÊ ƒÎ¹"$'ƧŽëƒLX¥•&¹»»«“““º¿¿ïò„"Ié$h³÷Éu™'¹JfÕ¾ùùù±2…™h™y!ÇRAfii©™om -Û™™™©ýýýZ[[«íííαÞóøzc–%\sZ³«««Ýž¬\ÂI IcMÌÎÎÖ`0h ­?Ù¦éé§êUäéìš[nó;ÚaÌ1©ìÞdvYtÓ‡ï‘pÌ÷•••^ÇæÌÖÖV---uÔˆ® Ëv«h"Š£oDUšÁëûwïÞu~‰y®cöíÜÜ\Û!ë>#‚UOàþË/¿¬ª‘s‡™¯ª–cYÛì“÷Z^^nùÁ @ʘ7¤•GGGµ»»Ûàøôô´ûó¼¶¶Ö9É~ŸžžöûU=úzrrRm÷ä™o‡‡‡µ¼¼\=&}2pUõ!}³³O¹%°æTyãd§C¨?­ß[]]m’Æ8xž6š³æÛÍÍMýò—¿¬ƒƒƒ cIÔrc&Ñçë㺞Áü'p¥ÞNH"‰óöö¶sEÙ¬ôÄ1ßß߯ª‘Œ!Á¶²™œNßôôt×…w/‘r͇›››NÊϾ5ÆËËËõðussSïÞ½«>Ôp8ìÚíWWWµµµÕkN4C{½³9-Ç@ÞŒu \#¬KRUö±c=šÓò ØÎûsppP õîÝ»^çÖGãë¢Ï×Çs=î'paDªjŒõ`|°T€Ÿ ‘yŸå»TÒ¨ª¤ îÊÊJobpd©PcCNI¶Åfǘc+SSOûÉÁð¾¤0î¥\F`‰&‘=øþììÓ©Ò@P& blŒ©Yo-ŠhhŸÚñÖùL>Q5~ú³~˜9ísssí>Žn·›sÙýÌÛ~¿Ÿïç}«=’·¤———cii)ö÷÷32‡¸xj¯n{ó¯AìV­ P˜DÄ»¼O“šÌ<¸¾ÛhLj Ó¨W&”añ“ãÌ=kÕÝJbH*8ÂûNyµ‚ƒì^•M« WâRÍ œ*KâçÀ†cÚ•d”FF<"xù>ƒrvv–QŠÕÕÕ”öõä`Ää £:¤˜d}ìÙÔŒ$IÙ|¨Œ™9P«6˜tè®1ã?ÿçoÄG?ú±¸½0±•YöÝê TIL*ÔœˆêÖäCÀŒSQµÃþw‡F@µš‘9®rŠ ´VNâDy晹¨/j‰J €ì F D"Œñl^…q´nDh¬Á*# ª+22kSò­9âúÊã¹n¨°Á1#Oâ8b®áââbö¡3.8R•}2·ÍOy/>ó¬Îu÷òî×××SÌ­y!º¤F9‡É}Eâ*Q!YR’4P™ôì;Uöâ™ÍMzo6Wi\Ž]=Îõ¬ov°ÚáåååtDýQªë}Öþ±CdH¢/ÞK¤ÒÜpMÏO~hÞÜ5š©Õ¨žg¨Î0çEÿ×w2Öö$cY#IH ·HŠ‘=,"rü¼—¹óöÛogå#Ï‹Õ÷9‘Dy›•••_÷”?°³³“vŸƒÂ¶×ñŒ˜8‹ž©Ê˺Ýn2ïæ¬Ïxî­«²'{TuLŸÚ«ÙžÀükÐZ­V²?•]¡}Å—UÒ1©šT oÄ$Ù‘öPyJ?ŠZNl,B-±VYc'–Ò û˜²¬Z¢õ¼tBÚ ½çµÑbÛ„ŒTHÑjs$0«ú¢Ù4þÌ:ƒ‹]ìj.€wÀ¼V6Ê{â@›1ްVœ/`…Þ´nÈœˆˆ˜*sy||ÛÛÛùn´Ó6!‘”1ñ|•SEH´ÈFVˆûw»Ý©Òzý~?çAu0nnnâð¯ÆïýÞç㓟üÞúɼsà˜¯`žÉÀ*Ë/p]Œ™Px•—U†D|ªUÁ#Çë`쌧Öýý}:UÚvuu•'·Wl©5ëðŽõúúz£Á`sdww7Vs±FÛ¼IÆp8œ’!ñ¤`Íf3kã×c`mmmm¥Ü£×ëMCú|kéää$l¦*Mœ5`Ǻª¤†g匓R˜“ÛÛÛqss“U_¬_ÿì÷û™ HšÏJ̺‡hƈ¾¼óÎ;¹žH?ò‘Äòòr|ùË_ŽÓÓÓ,ªÏD 8ŒäzÕÞÐR/--e%ëÔ:aÇ+É`ÛWH2=»ÊÆ(U*ò'Ræw¤Ÿžq{{{êTpsSRº¾V¡H©J@Ék Ýô¹ì=§ÂúÑÞE¤$Ë»»»¼®fX__ÏýLôÄ~!'C½ÿýïÛÛÛÌu9©28ç0Ô=Yÿ___Çúúz ƒ¬TfžÈ‡ÇñâÅ‹xj¯n{ó¯AS‚¯–™« £µáIÔF¾&‘PËYxYr#ƒíó67†Ë‚…`0|5Ãhé9\“”§ðRõÂUFBiCüéÉonn¦žkǸ/--E§ÓI ¤÷©UrŽŽŽbgg'7?ÌN³ÙLë™*˜oµZ±¹¹9u¢¤$Kì>‡Ë;:dG’r•<Ôþ%ËÁìê*oü8`Ú€m¾%+++ô¬Ñ i{ϺÁpº%¬êååen´Õér˜‘ñÅ´yÖÅÅÅ8>>ÎñÔ¯?GÖóèƒN7·Ì àÅÚ©ÉØ®oNéèl_e²ŸÏÜÞ>6D7s¯^/bRQŠs}{{› …[[[ % —ÆX¬,=ÇH@Ñ[»zxàd-ý'''yð g®:ýÏŸ?O0FÞRkãsœÞ«~¸¤pÑ3ãç¦×ØX£µRk`Iå¤Ôõzxx˜¶¬èüü<ËÇš§ž#iKÍiÑà™<°6ë’ãÝh4Òd[·¶¶buu5vvvÈ>þ<""Þy縻»Ë²³þD<êÔI;Ö¾Ò¡æR%}jò¦( 0MR£/šÍfv¹—è%€9°Ø|‘# y4ME*Øš stt”‘)¹[ :XGÞ}ss3Á·kš?îË~èŽ ç[cwª,n~~>#RQ¿µa¨ç˜+r-ØJ9IÖ&'Ü^]«}Ù‡âÍ7ߌ£££Œ@Jr¾»»K ÛS{5Û˜M&^ø:"R < 4ÐYÚ´8úáªR0#B{BÈ“Š7ä%þª†»Èð0®ô‰€P1aµ±ï؆¯ê¢E "&¡f@Ó[Ë)ÞÜÜ$3I‘®ìf•ñÙûÚ1,t"5<‹­SWÜwj¥©q˜ŸŸO–hJÔ@Žˆ„•ÄöªÎÁÉét: Þ¼7Ë&Žã$p0Ÿ_ýêWâ#ùhŒÇ÷©›¢'k]Ðv"&,6]uŒºaÏÏÏÇææfž:;£×ë%(pê¼Ôðs‡µŠìzje;ëÁ÷ ÌXe:+{,±°°'''éTJšuxgªÐUç3)‹û‹œ­šG—9´z½^²“'''Éxcr <熳W}Z~}fV°‹m4órœvK^65´$|×ñ•O"’!RgþèwNy]§æ¨q6¶lgÆ«/ÂÄÕ¨€UŸ¿¾seœ ÙžwWYÈš988ÈyƒÑ YûÜ5¼ÿÃÃC’4öU“ÎéEX)ÖR—¢UCÎY4— ÖéË—/SƒÏ±Y\\Œ½½½osb®®®²âUµ;€vÝ#Œ‰ l¼$æããã©êD".þﳪáT»ÄŽYOÖùÒÒÒ V·îméô³ÙöŸ#}¬EÈÐDŽ"&ò-‘÷@l˜‹dmªGy&QYN©~{ÒÌ¿Úí Ì¿& PÂN5›ÍdT…‹m4¨5iPÃìTí²†qQ±¦^ÏF7Ëhzv«ÊJ<Ý`#&:ìzz]ßóXc,9Æß¦ËA©@ÀugïUuâœלí3ß]ZZJ†¦J–ô=IÍ,è­šÈ*e¨ár²êÐõ•ëØjíå >hEëØù¾Ínv¼1h>WŸ‰ƒd>Õ 6Ø(€¦jDm¸U§ìk¿˜U¢xþ_5ó„b<°º*rÌÎ#Ï_%¥¹X%žSx¿‚ïŠayª•.°Æ>_sIÜÃ<8>>Žëëëdߪܻ, 4*{=ûεúSçµþv=À½ý-—ã/+j~ø·µ ÅsÖˆB¢®û*%© »’›5zSË^êk?ç°“5›Íi¢,^6­êöýnii)ÎÎÎò,÷ñžì¢wM4Aˆ˜ÔIç°¿xñ"¯sÀY­¬ÅYÁôzÏšwÁ©`w̧YíûÒÒR2íU£$M7Œbpâjå/@Þ<›]»ä+Õ±a¨ÏPå—æWµÁ>#éØz«ì¹¾¨ýP¥]œvc¨ß¬¶‚d!¦Ï777§Öƒy ;N4%q­¥Yy–ùkŽ˜/ËËË©Á¯kÕsоÖ~b_«ƒñÔ^Íöæ_ƒ¬VC Zµ¬ P†A¼½½Mݺ2~X#›5ÆÖu+8·QÐ,GDê:<ìϬ¤ÇhW277—R U(€2ÆSH™áôwÄcýóZ2’„ÅóÇãdWWWSûN¦¤ª Ã=77—r‡óóóX[[‹íííh·ÛSŽ„V':¡ÑûÚ\j4c6!MU9ðTBò@hÖ*#&y3 /Üß1äµ·V#,äU/+Jáýë —µb Æ¹Ž Öñêê*kk _«ÿ ürÌ?} ˆôIDB?‹\ˆlpNÌaß[\\ŒÃÃÃdÔ¬!Yr«ˆ o}‘{!ív;™ÍñxÏž=‹£££©ê ˜æ•••ÔÅÇã¬|#2$r*!ýî°¥kE Ø•ª0·jbû>¹™ÌÂÂB&LVPNÁ±>::Šóóóxë­·Ò®.Ýn7VVVòžu ×5õððxÚ*iHDäšn€Þœ›ÖuĤV-=hüÍ)’EIšµ´%gsÏ&€´ýýýðÖ¨¹ê9jÕ.Ñ8§¸‡Ã899‰µµµx÷Ýw§ŒÍq:lãh‹¼ŠNTÀ‰ùå`ëWû€k“•˜OÍf3m€uÉ!åˆò²'œ%vz4Åîînœžžf¤ ÉÁž3ë‚­;::Ê 6µ„ªÊJ³•¿$W î]ì?Öß`0ˆ“““¬žFÞS+¸Iäö»Ú§ÕQY³ÎÎÏÏS.Y¥=œ*¶¯Fÿ¦ªl5›Í,‡ÊVŒÇ¹%õP¯ê?µW¯=ù× a•lT€{Ýk™M܆Újµ¾-”Äuä6;Œ7¶HÈ“PP¥4€ÐbÝðê5€ZC˜»dC±¡@ƒ?ãñ8Ëóy†Ê–Ì2îX'ÚÈÙDVjÚbl•{ÙðŽŽŽò]†Ãa2Yt¡ØB›{×1Ð÷Âá´Íµw«Õʃ¡*+*AÂÔ‘Uý¦>'aøÆ7þ8Þzë{âòò:Að´bºjÚ³EL*þ`ï+¬:T²Š:®X>•P""Kªz›ðúúzÊij¹Èz¨W`ò1_N.%9px Æ!¨ár€,DdhöP‰g&îî&å nEÃ=³¼âÉÉI®M€aÈ#""%Æúáá!e\$Q³ŽÀx<ÎÄ»N§“ ‘ƘXšÍÇzð˜çùùùøŽïøŽì‡F£1u† 4ÖרWYg­Ó^›_r¬çˆI©Cö@•›ˆÇ$÷7Þxc*¹Õz¬­,s¦Ø”šã£­_LëÁÁAΣq\ZZŠƒƒƒëã“ñÝÞÞF¿ßÏçÄfKÐÖŸÖ8)Ëþþ~ Ɖ¥JÝÈ3®¯¯¬ßÝÝŻロ²?c‹I>¬s–c;³#§¶Ê•¬÷Záhnn.çM=¤2õ•İfë3Öh g‡ù¾ÆX©RûG­„e|k9LNªýÁܲ¦jNRAÄ‚s…|šƒ“¼sguu5vww£ÓéÄÙÙY`e?Rþ–SY£ÇÇÇSÄÄl$ý©½Zí Ì¿­†×jb`-i‡™Œ˜„­±Õ@m=äE¥ˆ£¡àÈSîïï“5ªì•MƒÅ@V1 ƒ“øT‰PM:c´€&šc%Ê„^ÏZa$bRט#¡R€w¤õ¼õP¬§M¾:?ÕÀJîZÅÙÈÜdzq<“÷¬ ªÞ(«f#«`8cн§~¬šîˆH…úæÈzn@ƒCSÁ}ÄDCŽag–Ø IDAT³aF£<åý8Žú¼j´9†@ÍíímJlêä-×××ñå/ÿ~¼õÖ÷ÄêêFnþ´¯œÌ¡>©óÍóø]ÕôšW××× >ÌãƒÄ€Vù Ð`›·i×5¬UNñ¨¦ëø¾w­Q1k¥ßïçš4&N'Y?cK²x¨v%*ĸ®ùH÷ù$u¨ÍWãÊ&9å²2ûúáòò2Ÿ¹FàD°òCÉ¥8YÖ¢9¤ÏôOë+ßl63zâ÷þ=kÏ<Ÿ¾©8ËnÊ©e+p®‘}ÌÆÞÞ>ž °ËI:??Á`gÌÊ[ä/ÔÒ¢úÆ®k·:͵’PÄ„Œ1¬YŸ3Øeý¾¸¸8UÁÊsa­ýÂÂBt:¶0"² ¯ˆìì¡„­Vkªt¦ë³ÈªigÛ]öãÄÆ:IÛÏÍ©y­²7Ïã}¦Úëâêê*öööbkk+Æãq|ë[ßÊñ±²¡¤6®§ï«|ꩽºí Ì¿Á®`«²à¤‘òÿžŸŸÏ“}—qcøge75q®rªø…³12>ÃàÄŽ)Ç¢‘„ö[[[i1MU_(9N%ï‰ñ«É‹Ãá0³°Õ‘ÀXÅ&‰ácèl`6:äåååx÷ÝwsC <ï‰a´ñTYP›ú¦Ê’°ÿ±³ŽL­xY2­nÖõøzÒ²¬eÝ,lrÞÇÆ„½ ±™@¶9ÉY^¶19'ÀÆp—ÇÇDZ³³“ÏÞív§’k=ŸÄ³*éÒŸÕ!RD3D[0Ê6gÏ®™û6ñˆÈj¢6œ²•ú]ɼ".Nýæ7¿™@ ôNÔ†Žý¯N«õNzà´ËƒƒƒŒ„T§›jÞ]\\ÄîînÎÛªÏ%Ó oîÕúÞØLLi¿ßn·›R»V«•åÉ:m¶‹ˆx¬æ2[ÆÓZe”ì´öÞÿþ÷ç\ÓP×­ù’Rg“7õK-g T¹—“[«,®:ŒÖ,f5[­ÖÔaZ’“E¡Ô×÷ÆcbåîînŽHÅÂÂB:¼l¹×`0ˆ‡‡‡,ýéy‚¬ßgµô“ªHu^[>Ôs,ETÌ5e¹kÚj„MÕ˜ ’j3Ѩ“““ÜH”Ì“^¯—ó«&ù’EL*ž±©ö7ÎÈÍÍMF·ÛÍyô[cé亮ȩ$es ®çóóó888ˆ³³³tBjYYÏ¥}]'~W¥7OíÕmO`þ5hõd¿›››,W%ŒŽ}¨aýˆ 1a°%Ãá0Cµ˜PŸ©L¸ ³&‡V‰AÄ##áÈõÙ„»ˆ Ž˜¾AvðÜ´ÂUV# ˜\ÀËRC¾µò~ZXXˆ^¯§§§Y&òää$vwwS†sqqo¼ñF,..ÆÁÁÁTùG ¥VÅQ¡˜ðÞJ°E4¡@ºÍøgðýÜX|mšXò¿«‡èp^èMoo¸rŽ˜8‹“²–žÅT£À =¿~-ñX’îÙ³g1¦*]qËðyzS –(ƒ<Ùˆub~Çã8;;ËÙÓÓÓÔÁÊ1¨aróp®]y—6ÞÙdHßQ†µ²v$o˜CcäU¬bQ] ñ;¿óÿoZ§öÿ¦}æ3¿vGT@䈆dÀàVÇ\¢2A²191šs½¶¶y`U-£[;„­ó………xñâEFjô¤JÄ"×0_ó^jø‹VFL"Àg§ÓÉHžßÉq…ñìgggY¡æópLüaσA¾«ýƒSç`§z¶ŠÊ[5¹FœDkD"OOOc{{;£lU¢ñÌëëëy¸î0yVÝn7Élºþ«9J÷÷÷y~€}Pî>µW,.>ÖÈ'Ã2ìÝlýS{µÚ˜ 0Wõ‚ÂÎôzB¨X‘šÈÅ@ÒÖ„WŒ*&C‚¬ë(ïU ”V% 6ZÅu8 ´1n˜%LsMü¬ÉUb¢q*SïA™l Xz'ÏYò ë²¶¶6uP ¦¢BMÈÓ§ô¤’½®¯¯3_0•”è{€2¦“ƒd,j‚ ˜”~@—––rÓÃ@rŒ# îØ÷ÚUÂR•6†6š………ÔW»N Uû¹÷ö^›››Ñï÷óÝX}1}ÈÕ{•v«ò1ÎnÄ$‰¸ÊXG½è°|qq‘ZYsTĨ²ý nŽb÷ô™~ ÀäÖê>#&r?³n0ܳí¯ýµžŠ(4Õ5蜫/¹Özn·Û™¬í¾úÁœÒ0ùÆBTƒ¯¾«Þ«««8;;˹…‰%Mã䯯¯g‚,gФÅ<ætËYaÇ8ìl 6›DÅû! 8ò΀0Ç«¼îWõ×â3ŸùÍ)¯Ú‰Êþ²7´÷@£Š%æZ)‡i{'¹7XkïW“Æ+K+Ÿ†ä‰­¡ëžŸŸÏ|É÷lç7°…Éœ«oŒˆŸˆH9¡HÛÎïf³§§§©kŸÕ|/--¥«J¢æ~Dä<à W‰i­’ÅÑbGDr–––RÚcìôs•ë4Ý³ÕØj”ˆ`CZ­V¾ËÞÞÞT»è—øÌWQ)ÕÄf÷16»ÕjÅ`0ÈR½ÖËS{5ÛSFÄkÐlžµŒ^5l˜íôô4YW]yDLmU ]¯ãw mĤ¼Ze6Ü¿&öøãÙk6>@X“ÝÏsÖ,þ*ؽ‡k{'}äºî5ÛŸ>ïo!ïY1‰&aõÝ“{Ô¹3k»ß«ôñÉÉÉÔóÌ^×µêZ°æ8Sú´Î‹:†ú¹Ž»p½_mÙú1nuÕw«IâžµÎwst6y¾Þ}5·fÇFŸHÞÝÝÍ÷ÓÖOÝ#¼Çly_­&$û¼¿«Ý÷ÎìÚéééÔ½«Ô¨Ú&}aÞ"Ø¢§öê¶'fþ5h©‘zAZpìYÄÄØ9<„ÖžA` hÝgÙ玲Œ¶Ã‹fĨÌêÆkòÉöBR“ß“ŠDDV°Àž`81—Uz„Áfð„4«F––{?2¯†|k• ìãw~çwÆæææÔÆxss“Õ(lÒWWWq||œì¿,Ýc­<ÅÕ¼çââbVcÞ6fB´@&\oc¡‡÷L¢³ÑI¾H1èsssY…„üf0¤,¤F*0Ôù¾Ýn7úý~ŽIeCÉDAZ­VʆÖ××3úóŸÿOññ"®¯'ç%HŒ õaM V^u–aŒˆÔ»ÓûMú”'P× ÙK½Ÿ¨J•WÉ´Ö•k’?ÕŠ+ò3lì@e«iô”v»,¶k®¬¬Äþþþ”ìÀø_\\ÄÖÖV&ëYtÇÆPŽ„jï%r£·g°öUUyñâE¬­­Åæææ¸UX&gàŒ‰4²=´Ïtåõ´×Z*Óx(Që ²Ze©ÙlF¯×Ëœó†Ôåöö6~é—~ù/Xù³ŒÞɵ¸¸¸Èùdž‘«oÏÛï÷óyÙ'vN…”š ÐÕó£„MßßßµµµXYYÉ„Nó :ä/_¾Ì³ÁóóóÑn·Sÿ XçïEu}×x×ÃÓœþìw¢cF#^¾|™É¸Þ´H…´ÅÅÅÌ59;;ËÏ9uØ3Í´þÛÛÛ¹²£ìˆù@uxx˜ÿ&¿Ó¯îãçÝn7í»UåÞïìì,ǼòÅÎø½H‘krœHïZ­VžΖŒÇãdé5{)‡f6ß㩽Zí Ì¿­2’Œ—J µÌ\-§ÈøÆãñ¤dÐ]YN•c°N§“˜ÑhëëëSlÝdÄ#“HŸŒy±!T¬&Í5›Í¬y]5–‹‹‹y8HMòU^¯Ö/&Q‰ˆ”$%Ø&¦™‚…Æ«æÚæ,‘–CóÆoÄîînüðÿp†®?ÿùÏÇÁÁÁÔFçÚ[[[Y%'"ÒPWý|Í5Q±&EUy}¨M̳UFÕÆïgÍ È4.ÞÙ<ªºv0 dTÇÌXÝßßçõͳFcR›03gk5"ùZ×+1‘QÕû{6ZIÂ'Æ3Z µRÏ ~îs£Ñ((¹„èÐAîsww—¢9$ÔãÚ1ŒÁ«” [Èa­U>꥕6WHvj‰< Ëüje*)X[[‹7ß|3¬¢OVê¯Ê¸ô=iˆ¤ç“““)pjH¢•³€Ñ½w•BqF:²äGÈ‹šÌKGn^WGªÙ|¬}_Ï ¨ÕŒØ6ö±F¹€/U“ô›õ¾µµ•²5ÒŽáp˜N7ûÂ6¹®¼ T+òÌl3‰m¨àؼ$?kµZ)Ò¯ú¤ZçÝÏÌYYfežçççckk+nnn²„*g­•oÌ'W­·¹,× ¨—,n½¹ÖCT°/d% ÍY¶Ö<")´Î9>Çyõ³Ôî×r®Ö’?µœ§yÀØôõl¨±˜D!fÐñxœUÆìÍOÌü«ÝžÀükÐ4 ^ÕëÖòp½) D´Î6x†þììlê ¨Zuxq_›_Me¤%óÔp©Ä?%ø$Øž>€ªšAïj£'‡Sy^ÆžV0Ðõ„2%cqÏZ²n}}=šÍf|àˆú¡ŠO}êS b¶¶¶âOÿôOãw÷wãOþäO’¹¬²›………Œ\0þµr£®¿9œ ý¬èív;V»²¿Ø:Òcˆù”x«¿°ÑUbãÐØßÊÑ”ge/mò•E²‘Ò—GL×.m˜ÀˆÇruý~?¶¶¶r~]^^ÆÆÆFÜÜܤ¤Á3]]]%S ¸I@\^^Ž£££èv»™ÔW¿G7c–k¥"}Í)ˆ˜ÈP0£>k4ÕKœZ ñää$¶¶¶¦tÀÂé•¥4ªô¬ bmm-ŽŽŽR*U÷Ÿùùùt¦%†ƒèt:Ñn·3:b޲/ægÊÜ@ÎØ7D09ºÎ¶xã7$s|ôq•îÈò–ä°_öÎ:Ÿåc8¼®:[ÇÇÇ9ö­V+ 4<<<ÄÛo¿‹‹‹±¾¾ž4ë^pôýápÏž=ËÊ=µÎ<¿¹çœêz0àS{õÚ“fþ5hï¥ÁŒ˜®Ë^™ðÊVGDVKîêïë*>ëž®[+¡`ï#"C«•1pOx­¸‚^^^žJŠA¨›m õz~€¤jm19µdXÄdCÇžFL,Â$bŽê»ú#¡ïùóç±»»›@  [^^Žv»Ìç 3Uû°ôÇf¡ †1ñÞœƒËËËo;Ý´2Iø»§²†Ø[ ’g¨›3YŠ10Èr8@51׳kÔ,//O%L{ßZ?bRBP_T}ªŠüÃVÙ}!gïm^bÝm~@ í¾À{ÕéÖ¹9.5l¥ÊœjPó×üòÌXöz}`Á\2ëûxÀâ×ÖÖ¦$F¾'aÛûL•hq õkDd”‚#X# ˜Bk°á€°ñ¨ëX׿+0ʱ´Îõã,¨Ì<ŸçF™”X¥w5a¸jø§¥²Öô×îÔ9Ì®Îk×B ÔŸ¿W¾ '„£3k;È+5þœž~¿ŸÑ!Ñ+‘úïÙªQ7k!d~õûýCc†Ý—0Mf¾Ô(’1s¿º~‘È!UhØ'sÏ<­rQödvß‹ˆ 1 ò<€ºWé $TµIÆÐ:¬ ëoŸ«c œ³;Ñ@sSoÞ™cl”(zÝH«È’Ì7¤ÛS{5Û3ÿ´jT†ãE Ͱ9ñŽq­z{áTF˜Ã2ò•%³9 õ’È€’w""™³ˆI¥›LeàlÊØZl•ͬ°d“¾l˜?¢y÷*Ça4[­V¼ûî»Ñét2DïÏêêjììì¤NþÃþp&‚9Ž~4z,¶±±‘5Ñk¨’“_ùÊW¾Mª|WV©nê6W ;é4@ã‚¥©•”[¬ÔXV™LeT[©Nžvyy9ëùÓÕªB¢¿1pê1GDFHŒ3pš˜öÙìëëë¬@‚ñÇú¡—ùDÞbÔÇê²›g''')É2žÆÐ»Û`kÙÑ êÉÑö÷÷s.Uý®õ€Aç”VfVÕ£¹¹¹<ô©JT)±.#kWw:899Éõ]þ¬eëåêê*ßÕZâ@DD‚ó‚æ×9 ¹(Y›ÇòrÙ–ˆ ÀÅ`×ÊQ­Ö㉬½^/–ùoýF£ÑHm³¾ˆt®jiUÑGÑ£*áXYYÉuü ¿ð‹ñÙÏþV4Îq¿ß½½½¸»»‹—/_Æûßÿþh6›)#“ëamq²:NÎeÀoee%£sªy­®®ÆÙÙYž?ÀN²£UÇ gò+++ù,ƳãN§ÇÇÇqww;;;©ãïv»qrr’å*=3i£ùª$/y—Ü+¶¡Õz<¸÷η··™Ûr~~ž²J/„ ‰šj~*ëkþ’T»ÀþˆœÖh3g…,¨FsVVVâèè(%65b‰L#CD†DÕD:ä†X§5šhßÝØØˆÁ`¿ëõz™${ss;;;Ñétò@²“““˜››ËˆÉS{uÛ˜ ZÕVGLBµ FE‰±ZÑ#b"i`P0ôj•‚ÔKà0¶a %bïîî¸ÑH×dÏj#"Y¡D%9Fšv±21UË©OªÁÿ[­Vž°É°+'V¥U2ý<==?þã?޵µµØÙÙ‰|ੳm6›qyyögßüæ7ã[ßúVja•—sz£²d“¼`ûüü<7]¿7n˜.館Ÿ±,/M ‹WÆ<[Å9TN.b¢¡˜8BÖò 0\ú®ÝngÙCbÌ6Ñû­V+ðádâjýþóÿ)¾ïû¾?Æãù|gýT¥<•Íò»F£‘Ò­‡‡‡ØÛÛ˹ïó€'9ÉÚÚZÜÜÜLU‡ÑÆ£úK¿ßv»ÉçUÿ* Óq쿃ƒƒØØØH†h,¯®®¢ÓéäÚª•yLû ”a e#Šååå¬Ä£BNeÆé‰ágÏžÅþþþ”Ì@5œÅÅÅd)­MŽ¡{ÊñlU£™OBþ0 r¾ÖhçÁ¼¨ýˆ}6_ÍZ}Jb£qä(°•Ñ}÷Ýwóù···³/èâÍwk ‹Oò&/¢®a÷š-«Z£ ÎbM0m·Û) êõzScÌ~W{G£1qÌúý~FÖH}8r°rÃÃÃøÐ‡>”Ž_Äãž#I¸æÿp~Ùv¿ÑhÄññq2ËììóçÏӑ‚‹–,//g9M©ǰ&˜WgØÞX‰{NÍ!¡à0HŠ^XXHáýüM¢ÆIeÿ5 Íñ‰˜®òdΙçççùN’j9ªN@6ÞœÐëëë\OíÕmO2›× ý?I|©€ȱ9c<€ƒˆÉ‰œþ1)ÏUcYjHuöþ³¿³Áûw-ÏWŠúýzš< ¶j¶ÅdVf¥‚Šj#bªd#~zzñ§ú§qpp¿Ãê*5VKGVgçúú:uëõ]ýѳϯéçÙ±™_fÇdö»õ÷®aÓÐ75ÁSç3uì«„©V´«´¡>§ùÁúIB£ëÍ–.4Võgªªx_Ïëзü‘×ó¼µüaÞ‘ˆƒYŸ£öeíïªç ëf]¯1û^³ï^çoMÖZHKܳÎaûú|µj¿EDVœ©cë*Iàßµ>¾ˆ@ý^Õçc9k9GsÏܨ¥!k9?÷­Ï¢_]‹RŸ¡>³qþéŸþ™< Êg­— ”Í_ë¡öQýü¬]ªspöÊfú\ýN½/GŠ´Ð;Ï–í­QUã:Û—³óéøøøÛΙ}ŽÙ9Y爟×1´gÔwžWú©öA]¿H#×3WÌY?Ÿ]oÞÕ³žžž&›?;ìŽõ^׫ëÕ¼¬Ñhüà3zW?Wm¯±ˆˆÜfÇ´ÚQR}©¿åÕýˆMzj¯n{bæ_ƒ¦ê#ƒÑîÆð0vþÆŒÖ2‰Æ‰EªZÒZ=›¤òVŒf°2"Âã˜ÇˆIüªEÅÆnoo'“OÂ(Ò"FDJ@„2#&›<ö½Ê„¢onn¦"À»k`Ã""™CƒAüáþa|÷wwVÈøÊW¾o¿ýv\]]e˜ùüü<ŽŽŽR*´JPKpbE`ðìì,®¯¯ccc#Wq0DĤ²…$Æf³9ÅæÚ($tŽÇãì3úxŽH…ÄSì˜Y̆n<~ÔùÏ–Þôü½^/F£QÆÆÆÆT•šš H¿.iÌܘŸŸ/|áóñƒ?øW#b9#EL©²Ÿ 4ETÌM•7ÌI,¨yqqq‘ì­¾QYÄ;a0±Ø˜Õzz¤¹)9Œ0jÞµ–rŒˆŒ¼H–3†‰ƒ˜ïêÐWýzÍM!;ÞŸŸg®Lý.& óªì!»Q%9AfE¢²VÄä 6ïÁÁÐ×*_ùœuç½ô·ÆîIê4w¬[kÛzbÿNOOsN³'³ к'“‡Ðï÷#"òtäÝÝÝøà?§§§ñòåˈøöCÛÆãq¬¯¯ÇÂÂBôûý”¿œœœ¤)ÚbNb´É5HâêïF£QìììdB¤Ëüü|V «ÖoèUÃñȨ믕••ØÛÛK;Óétr]VÒÅZ6o#"£el °Îɇy™µ ¬èééi:ôo½õVFWœlkß©ED4j•™ábûE©D6Éñîïïãìì,´•ùMûnÚÜÜŒ‹‹‹ØßßÏ$èz0ÇC´µ’£Ñ(ö÷÷3zÉRŽÇ“CÍ»Q1¨V·êõzSò§öj¶'0ÿ4Ì—2k@<Ís-ß×jµ¦JYUb6¯&!V +cà ±ßÞÞÆp8Œ‡‡‡ ÿg³ìG­fB*R™baXÆ ð”è©<ãW“ 8.’ô|¸’I =4 521a=« ûûûSU9¾ñoÄááa\__§¼ BwhWD¤ôAâ%0ZKóÕ~:jM}‰XU³ Dbú$üÙàjÙLß·)pžêøèƒˆÈ÷*|~4¥óøzw¸ÕjeñštæóÀýðh4J < ŽjÙ;Ž£çõk£1©£Ì%ý¯RÄõõuÖçh­ R&¡pÏ_™MÏSLcÈiÆE7""ï§™‡Ö/Vn{{;ÌÓÓÓØØØHÍ5`1ɓ®2ïÀº•Ë¢ô¡5 |sÚ­%ŽÖââbž½¶¶ý~êÞ•IߨØÈyØívãèè(×_§ÓIçg¶Rí´õCjQå„ò~¼oQ€qDd.€ÏKÔ4H€¾Á`ÿàüwñÙÏþVÜÜ\§XË´^__'3~ޝ®®RÞD¾Síj­åþ››› >«TÉšjiúÅ“““ÌMÀÊյܨ&yë]×µÏV¢Frdæææâøø8z½^î)ìˆS²onnb}}=í%Ǻ:¨‡ì!¢¼‡ù³²²;;;±³³Ÿþô§³þ}DÄ‹/âöö6¥z‘c¤’*E$}òºÝn:*Cr/ÿ·Ïè%9JWWW) 3¦§§§é@s*óÌ_^^¦[XX˜JZåx›57‰#»¿¿Ÿ6–tФö©½Úí Ì¿¬`UÒb-‡EgŠ}Ä6¾ïcò$;C  ©¬"ãÄ¡jDl¦µ›Ä,L‹’pUŸQÇüÓFD‚à’ql·Û ð+ëA‹aôùZ盜CßaW€‚ûûÇŠ2âí·ßŽVëQ‹ ˆÉãñ£¾|8Æååen¼˜+›ÆÜÜÜ”¤„áçÜÔ\ˆ›››8::JfªáZ%¨ßï§¾C}{{›‡EDÖÀÆ,yæš¼'Ùêcûx|ñ‹_7Þx3R/Z¦‘߀Äà_^^& ”¨ì;ö""ó*Hl4ñµ¯}5>ñ‰OÆh4?Uõ!bRùƒ¨jÄDR„©}xxˆ~¿Ÿ‡ýؼÕ_¯‘Éxœ9ý~ª*ŽÈB§ÓIkDÄúúz:™æx||‹‹‹±¹¹™kΜ´ž%Öﯮ®æ:ÑoÃá0Á­Ä½ˆÈòª,š[΂PµI®Ìgškëž3l>{ö,ç1 >Góüü<%œ>cÄN6˜ÕéR"–sR™ËV«•Úq}*'ˆ½èt:É4w»Ý888ÈÏÒ¡?<<¤ÃYûÐ3;ŸXgÓ$&·Ûí8< Kªå´ˆœµ"›0gX8­Cí IDATÒ¬þqR*Ûa݉lmmÅÉÉIŽO«ÕÊH¢ùÂùâ Ú¢aÖFMbÇÙ+„9ÉVÚ#êöÞœT„C j²¯¨Èùùy®•J|ÍÏÏO• tÎè d}ëN¾HîlNDd1€ˆHRGB>{ä 2dû ØK¤}j¯n{Š»¼ͦïTR‹+„½¬e&gË…ÍnpÓåì\Ç=€Ì›‰ž‡^•án\ÓukÈØg…±#˜w²Ÿª#¬ ´Œ:6¾j4²#I´À\=¦jð½7` ÔHEDä³cp*(À(2þ‘ÌÒ{õõx<9ÜÆ˜égŒ¿ÍšÓF"Sãló¶!GD> I2Ñh4¦J2º¿MÐsxfý¯z‹÷æÈÕÐoe ïZROs£>¹¾¾Ž/|áóñ½ßû©Ü˜1°ØÕ9æo‰eÖ„q7lâ•A˜ZïŽ)Õwæül¹ÔZ:Ñ{ù<ÐY×”ÏèwÀȘøn—³4γ{Éáæ€Vï 0é óÄã,[?šûV]3]¶Ê!ÆÄ3pøEHV°ÝlT¢˜æ™~¨ÑQAöIª:?¤eœV…&Ròk¿ößįÿú?Nù¡ç7³ezýÞz6_"&pŽôh4ŠÁ`ÏU}oÔs1DWjiS@Dd$®æU¹V=xËX­˜#~ï=""ÿZɪFT­Žrœ sÝs›³5ª ŒFDæŸ$Šö^\\ÄÁÁAœœœäXoψ¼ÒUú1ɪ뼮}€°±N¬g1RB’²U«Õ¨DqëYý¬Î-û®q››KÀIèì2'˸Èo˜µ£OíÕjO£û4²Þ#¹©LLÕ`“™Tò¬’±˜„ +È©²‹ˆIb–¨Å|aáªö]¨(ˆ,¥ç~U)Å3 }Û´ÇãÇrbðuf¬k¥ª1=°a§ji͹¹¹xùòe\^^æàï¼óNnNÃá0%6ÉZ+¼ö±Í(èPp«Â†MAe}G;o.DDnXUj°qØTmRXÍú¹ˆ˜ªtqq‘ ‘Uß1IFœ0¤Æ±:6Xºf’Ÿqcððð%ÚŒpIk^Y/ã&´^Ù² ÔlÄUŽ)k¨ŽÜsÄb@æ]+ˆ ÉÑÿï{ßûr €†¹¹¹”2ÔMß89ø)âQÒRìë¼ÀtV…ˆŒæ,..¦ Á|Á8nmm¥ôd<§¬D“º¾èñËúsyqq1õLtÕ*†pÄ€÷ >E«0ã•å÷.æ|-¹ˆá¹!-¹¹¹‰~¿ŸÒ*ï·¾¾ž“…®k‹‹‹y˜2‘>玎2²U˶Ù«««Y.²:µª9< 2j ÁÕ!;³v°Ýõ„i¨ y•5b_aoÙQϽ´´GGG1§¢~c«$ç¡×륓e=±KKKqyyo¿ývöÝ׿þõ©yÏ)7·F£QV É|xxHSuRwvv¦Î9fu¯D^ؗظ›››8>>ŽÝÝÝ”±ªd£”¬Ã¶Ì±………xùòeJL­G}'^£Rú¯–X®ÑRŽmµ¥OíÕkO`þ5hÂÓú^ÚËÊDTdÄÜDL›Ñ* UÙîÊ FD†ûl¬>ã;>ëÈêv»Æ ãéyIS0œXºÅª‡Å*y/NÙŽïDD‚)€”ó#Y¯ÕjMé‘%fI ­¬òÉÉI‚Ñ^¯ƒÁ FÞKÈUX›U"àæh“d«8©'Œ’ELØ2 mooo ĉrÔñ¯Í¦nClmÚÆØg#&'³Ö¤eïKZCÒ…}óL€‡R™Es•v™C÷Å/~!¾ÿûÿJÜÝM0,Y©™(…9»¹¹9%ýâ<*•Ys"HfÌK›·>”ävvv–NÀ`3ÆH×\ {–)4?IC`åJk”‰œðĶ–GGG9Æ£Ñ(ed®]™V8ülÀxüxØÐÝÝ]t»ÝtÜ8ʳ Ó+++Q?]KìÖOU$Ó×yŒ=G<‹­­­ÅññqJûÎÎÎbkk+t³=÷÷Éú#;Óñü¹Ÿûùø·ÿöííQ&–ê »²Ì¤FŒFcRö”4Êútùùùd5ÒQ%2ÖdíL9wÊœÊAn+!£b IŸbýÙ&äˆh¡Ÿ“ ©™ÏIà Ñ¨Ç ¡­V+õ%ˆJv¯ÕŽu?‘t­?c¡iF°tëÖª‰óóó,Ÿ;boo/?Ç)ÔÇœ’µ‘f“Ù°^¯Ãá0<ˆ£aŸc[¬w¶E’mDÄááaJ8F®ÿˆÇ=XzÑà—oLŸÚ«ÛžÀükЪ|"br‚f­-¼ººšui±â6F]ÛˆÈJ6´ªÁ˜”2ÃhIÄà2¼6y’ˆªºÆbû½Š1UÆáõ*MÁ4KزñßÝÝMmž•QÄ–ÔXSÌ9GÀ¤«®²@ÐÃŒDLNGä0,,,d˜X¿¹¯¿n²ô‘tû@ %ÐY¥žI¢'Õj=jïI$ѳ»¾wQž“$×a¶Zʇ?üV|íkÿG|ä#Ízí4ñ’öª´¿ººš€½J€U94ô5§¡Êœ$¸©8!·€óR£˜Z  x²¨Æ™óÁ±¬²€Þ!N@r•S™ûtºÕÚÚZFæææ’Ý6þªì`uÏÏÏó £ªUv$ýld'b’gþJv}xxÈj!ú`AÒ¯Ö·çªIŒ‡‡‡ñ¾÷½/^¼x‘Ï„‘g#ô‹H†D>‘ïeì9X;;;S‰ªÍf3Ö××s 9å‘uù9~ëëë1 (q´õ7{'²Å)­ë·Êø€¦*ƒs]€Ou¬F£‘ÕZTæ¡]—Ä1‘°EÄÔBlÒùùy\]]ÅîînDD<{ö,ç-ùÉ>𸸸H½¶hœ÷$¿à(`¯ÍWÏg Õ -ÊøÖ¨i¯×KÀÉ~ˆ˜¬¯¯çû/6J•5‘CãÃfpþüž¦Þ8Nañ,£Ñã¡rU¦Óëõòš"ŽæŸgy©à™cLÒ¢˜ƒyª/ÙäJ’T; ©&ÿVçãþþ>321¢ÝnÇÚÚZüÉŸüIìîîæº;88ˆ~¿óóói§§Õ°8°U+¦üe}ìߌ'Ƀ?õ¹j?ºg§Z®»3[EGh¸~·¾eÑêý|–eg£6ÚzÏ:nuƒ¨ÚÐÚ§À©*µÞsÄôñôGPu:.MÏò¥/}1>ùÉïÍ÷¡yn6›Y Æ»¾[û°²´u gç‰ûcófǽ¾S-cø^­ÎǺæê×kºG­‰­ß¼ŸëÉ+ðûª‹V2Ó=0„õÙýÞ{T–¶Ž­q2·­-ë¼çù}÷½ê^[/úÕ=]«þ¿’ µFxsÞË}gׯþª Œú½®÷Ÿú©¿ŸûÜg§æHœ8Úúú™:§ªíÒUþÀY­×ˆ<Õuê|©ïZgþ»®µgN©Úâ;µÎ¼ï˜£ú®î5‡¢‚åˆÇè¤=¡’žq<O%ýÖ?œâúÙ:~æVgþÔùWû«®CëWU,ý\×T7õ¹ô“=p¶?Ôyõ^ûn~^íT½fm"u.Õ5¡ÍF’½cµ»OíÕlOÌükÐf“é9á@ FC‚‘Žˆ ob°#áN§ÇÊìÇÖð`A""K_b*ûÑjµ¦Já¹O­æá÷UTe 9ˆŸc+lP , ˆ±æÍ×ëõòZãñ8CËÏŸ?ϰ4¶ëtŸúV?#QѾãÚ¾WÞÜÜ\V§qÜ8æOÕ!Mu‡ZžcTÇ®Jhª]¯n6’tõ•ùèa´Z­¼Þ§>õéøò—ÿ(>üá·ò¹j‚pD$“[ë¼¢!¯u —‹‹‹øÚ×¾?ð?óókçØ¹†Ì&ßl6SRbÞVÔúÀ¨š?ž WúºÝnj¬¯¯¯³/=G-J Vu­µRŠr•@P§~¿ÏŸ?ŸJ>µ–1çìµµµ”Á`ÌsNŠ”ñ`“±å$rÖLÜùŽëH6w*0¼¿¬åÝ3áµÕje²¨õ®v»µ(ÙÕV …LÁÁOúЪQ'€‡äˆ\èyñâEìííMÙ‰áp˜õõiÔ@'„’’Õ>1Il""ß÷ìì,íý¿‘èCâž…}UåE´´ê¸Ùu²ÅÅÅŒ ň‰ˆ]\\L9˜ì=øÊÊJ:,lM~M.U¹å}ï{_ŒÇÒ¬ååå´£ú«æ:ˆ š"êà×R“îÅ>*ˆàýôuE—Ï&ôûýèv»¹Op"D/Ì}s\±ÂªÊen;ŸÀžA¬Ì)·øYŒ”PMä£&÷Êï!-¬IákkkIpXÿOíÕlO`þ5hŒq•ÂЄû]ÄcHsöHèZåЫL`Mà ^Mh¬Äòòr´ÛíÔHªÓ=Ë’ªŠPµå‘à2"2dZYX’!0ÄXûÀ°Ú$ÈJj>(Ffii)Ë”U­ÿx<Î YÈ·&EDnP¤5AMXÙÏl^×××Ñét²Ô_~´¥5ä/Y­Ùlæ5RžT+]Чcyô—p/ª$NúÞš ,? ÓéäF©oÔ.â½­/ÈzH¼w»ÝŽ/ù÷ããÿDÜÞÎ' 5GhŽI`0®¬ÏÏÏÄÒÆFDþ¬Vþáp(gD.@‡1¸¿¿Á`¬æÊÊJêûÉ=Ö××´T­xDäweaóª·VÉÆ\yèt:¹iiÇãqJÁªÃxŸ’ UT€Î}ee%Áí³gÏøFLä Uv4 âøø8Þ÷¾÷MÍ[uФV뱤%©T£ñXÒ³E†b<ÍIŒ5ïF"ÔhŒ3 ±k5±s\5áˆ_ýÕ_‹Ï|æ7cuõ±ÿ€'uÅý pynÎNÍe@(E»ÝžÒos|Öº‘0ʉ4ötñœ8ýĹæ„´Ûí<ŒŠ“ÄÉqA•½øùýýý”œÆ'K4o­ßjËõ¿>Ð'www±¹¹™Ï6?J Ø–ÕµcL"¥\욤VàÜxKè=;;KÙ6ۺ猱µUÊæ>æ»5!מ(9ɤ2·8ñ’XÙXóGIàóóó©ü2E¬×öîì¶}ŠóÎþ;Óå½ò¡žÚ«ÓžF÷5h@YÙ>›bM†‹ˆ“5yÖçJ CRõÀ€ë(ÀƒëU†SµL‰ß{nŒ>ãesØTŒ–çÄ8Õp»g­ZÆ °+kE4+“S ´wåHDDFlž•mÔÏXÈʘWP[ÃÆ@É,ÕO®‰qâè¸¶Ï ‡Ãdˆê!˜ÃÈ7“Sgk)C›¡UŘV«úÐwžðù©Í­–@ÇS¥5«œ#"ˆ&è“ßû½ÿ=çLeá;ã}{{› bMì3w#&ŽÏÔ„]ýã9+ãX;s XˆÉEꩯžM"]•è§*!¸¼¼L¯±®RãmÎxÚöꌙs˜mœ:¾Æ3"2Ša|jõ@AŸÛ˜C€rÜÏ+aÙøc9N4Æ€Y-Á'bľ™7¾ïºŸ“$Z¢teuž]¿:ŠìŸ>Ô³I‘Õþ]@6,oɳÔïa•tó¢:ï€70Yí@% Œ={å”Ð*¿ò®$}«qygïÑÉ’Ã#Ò$JÈ1õ^lRDdô >ÿææf¬­­eÕ$ïW«˜™çÆÖMÆ 6ïý|6¡¿V®ª6¨·¦ë¾¦YÓ5 n¿±þ¼¿=WÓú¡VóÎ[™]«ÖX%»Ç\·µµµ©üƒšPýÔ^½öÄÌ¿M˜»&8U _­öqqq‘!ê‹‹‹¸¹¹yÏ Å¦[“áê†êúyfDdl‘¡•0Ä0bR]à šl(U"Ãk4›?½(¶Ó¦4©¡oÆãq–Öt¯gÏžeaÕš×jA•!¢Õìv»é¸T-·÷‰˜” “$W£¹v ‰ÃcÌ$jr¦j¤F¹NÜø¹±¬¬6GPU,œŸc¶8Ãá0¾ç{>_ÿú×ã£ýØÔw5,0f_U‡z êË_þýøÔ§>ýýú8/>ïâ ™štjn«ÁQÙÜÜœb#k¥%,½÷ùùyVép°Œ¹G Š‘ÏåU:ªN2`×h<–ÝÞÞε¥¼ª1¬ë°´´”µ©ßyç)Ö^?<Žœ´÷Ñ/_üââÓŸþ¾¾=Ç€#`ºÖÚÚZj’+KÀ@5âÐj=Vù˜­tSû7"ÒiÃ8ë_ž~j·Ûq||œ°ê'úI’éÕÕU– æïïï³~ýÆÆÆT"¸w0gDHêZP³_mòˆI‚ñh4ÊD@uãcï¼bØoo¶zþüyÌÏÏ'PåXéb¢9$=˜öÊìs‚8+Ö6Â:7ÖWWW ºT½aÃÚææf:ü¤&¤ûûû±µµ•@”Ü«Ýn'`­‡LqêªÔG¿qJ#œW“ UP°oœüv»'''é¨ârŸU“ÈËÈ38H r–N§“¶•Ã,Ç@?qHÉžœÞʆѿ×DlÑv»Ÿ©¶»\åCóóóÑï÷§NʶÚ["oÆÚ®Uã’Ø­­[šsß«ò¸Zù áb¿«ÑQ×;==͹XK³×læp8Œ´ÖËññqV36$Jï¥Õ¯’ ÷¯Ñ#ëÁs’?Ú“EG£ÑTBôS{õÚ˜ nD$ ®º&2Ú@€Œn=hÛÌÀbsmnä @`èØ¼•Îc°mzU«ñV–®†¤6ƱJ*˜ÂÚI>Š˜0r @WKÒ&Àˆ˜°ƒžÑ©‘ E"¦ä4à¥ÝngÙ@¬Šçç¸T i3llätíú½ê‰9[’0Ý °Lôƒ±ª‰˜Êl• ›`Äa‚°eÆÙXô£‹?ú£oÄ'?ù½Y¦€zxxˆÓÓÓìÿªo6›ñ¥/}1""~à~0®®&}È ©õ¥———S¢|Z2ZDd"¢1j”¦–ÀÃFD:-Õ¡¨y$d5iÜwõ›ˆ†õl{ý‚¥Å”š{ÖóéÙIŽTi‡éÜazgO v_cŒ­µÚkÕ)s¯æÏR-@“M1tÓJΩóóó©³ –––R?Íö°O€t•r\êúç `˜§ÖÈÍÍMt:׿ý·ÿëøõ_ÿÇq?J†wnn.A>ƹæ#¦@–¹ _k¤Rý*]‘ob¼»Ýn&*º€²\íáá!¥*µ2ܸx>QYã&ÊÖh[»ÝNûágæ¨j)æÖááa<{ö,£µÜ­}E¢ïååe<{ö,%0Ö=Û¼°°kkkù 3cËvvv2¯hcc#NNN²OkªýÈßäOÖ±„Þ*êcww7~vÆúÇÈSuÿí;rŽ"&Q3L‰ˆ)v™sóÑ~,þð¿ÿø'ò8<Þ÷w÷›ºïG?ú±¿¬LËGÈX\¿ê׫cJ6Æqõ®ò?4’ïZß_‰7}ã3†Ï¡Ìž·P“˜}V_Wý}=,Æ÷677§ú£†Þ=·ÛÍê®_Ãü=ýf“÷ù H5Ò*N9‹y6^Ql¯ˆÓóçÏóÚÞ @[YYÉÄG‰¾µNûÒÒãOµ:Q-áçoc `Фxv}[Elç,¸šË9ûO–Q5ßì„h’é´ælQ­§oþšwì3ðVçI•SxNL}D¤Dªê´«k^¸z‰”rò8GÚ¬íáœú~ÍI©Ñ¬:·g×SµK‹‹‹ñâÅ‹´}~nœk•!ãÂÑÖ‡@.y’d_2²Y‰%ÙÒÁÁA:*ãñ8e.uxfDC•oùù§*R•çÉ­`«\÷üü<ÖÖÖ2šêó•8@T˜gËËËqzzÇÇÇSó–ôª® ëÛ:zj¯n{ó¯Aà DDjG#@¿ßÏ*ÃUÁçl‚šïÖÄKškÛ0«^0·‘ˆ0:XÉ üÉD`›$&‹Ár÷½šŒ„õöŒ‘¬&æµÛíæF\¥%€`3[&­jë±pÀ¢M(±™ê×µ`c°—îQÀЩ—žËõ°N5|]“¸èy±³U"ÈÛd9c5'Âsˆ˜'˜.¬¡{Jüýþïÿ+1â«_ýÊ_:_?þñO$õÈ|¶”È3ØÜÜŒËË˩қœããã_•)Œ¹yf™Ë‘Tü¬2xÀV³iM<<<ä!/$#úÈý°¦@4à±··—²¿¯‡€‘áT®:uJÒé' R¤©:k¤t )‹Ñh­±ð÷÷÷ÑëõRß ¼cÝn7£BÕ)˜8ïïïãèè(c°FD]ÑŒÕÕÕèv»ÙÇ¿~3fd!¾Cfã½›Ò‰’ª#"yœ¦ûûûø‰ŸøÉøÿâ‰ñø<ÇPtÀýœø)b§ô{À³^¯—‘J ÷Ö§7771 RbáÝ.//Ó™ª'ã.//ç|êõz)-âìÔšêãñ8snäpT}~eŽkå ö¡R €ìÌÚ7îƒY‰½ü• Ú­ûG±æqÝßßg%$åÉ`677³ ¨L£ñX=H)×åååØÚÚÊg”kÃ’x‰xõûýÔ½W^’z•û‘ÞqàZ­ÇÓokäÕ=9"æ÷÷U±ŒKÄĹyçw¦$£²·N§“§õÄ=µW·=ù× ]^^f8~mm-7FàÆæÆÛb #O2ãÚ6zÆÂ&1 še8r ¡þZ†aŒ˜TYÀèÙ¼*HŽˆ)VÉïÕºùªVÁy ݠͬISJ)ÚƒA:2 ©Á·áŒ1 N»é>6·………LJµáúú]òSeM#âÛj› /{v‘ä\}Ü‹ZÔDA ð'ç”êµèñmv¤8§l4Å[o}OÞK T-.®eNÆíímlnnNaNƒ.Ð{W™–cas#í¢×èÌuãKjU(¹¾ïââbʽj¾*GÁèÚ€WVV²µ?Ãá0k’Ž‚M¿‚ºÑh”¬±Ê"õ:gÍ‹v»ëH/-='£M>§îu³ÙŒ~¿é°ÝÞÞÆÁÁAFNNNbnn.­ÓÓÓxöìYÊ¡Þ|óÍ©œ—ˆH]ÿááa‚&ì'‡×¼7>ççç +€<;;ËDh%kÉšà«yž*-‰˜ÔAç¨×zê*´¨T³´´”2)ï ²yÏ´°°v¹®½Ñhggg)_!+ä ’ù¾9¬B•$cs„cÄ–Öüß_ZZJö(e7ÙŒq%zØδ~ªÑ¯Á`ċȌñw6‰¨Ùxüx˜Ôææf:!µºg¥Óé¤ô†-õ¹³³³<ù9"¦JèJ&¯{ƒç"Ñ ±²²’öÙ<ˆˆ”#Ùƒý†3‚m—urr’sÄx¯¯¯§nÎÛWiÄcTi{{;Ï8ØÜÜÌ~ä xÇ­­­tíc5w᩽ºíit_ƒ† Ž˜0Ý€ SÉõo,#ãÊx‘¼0àØ v ø`ðlzÀ¹&Ä @V£oC³i`Il¶@ZMžª:I›I­ˆÃ9aÌk‚šd0F×eè9B³5{V™O›ƒ ÑU3Uz }ž&]ø“ärŽf:â`Í*»‡±Æ"Õºkw: Ë×D¯Á`ãñ8™6ã[£96²Z™#f“´Qé_Ž‘M3)lN61)ojÓÕ—Ø5,¤dg›´yhjXœóyyy{{{) ¨óÐ?;;Ë1©²}Ùm›÷ IDATJÏ µÛí¬ÚÄy¬Ì%'ÔºĬM`{cc#+ÏÔ5îÙ=§9H湫ü0h·Û™Xiðë™WWW±µµ•Ž-€e=r¼>ŽN§“¿¯k1"âùóçét² ä}Æ0ÜÞÞÎ5ž°æ:'Z.Àp8Œ—/_ÆÆÆFÚ÷ªÁwì÷ééi3×××±»»;•wAn®pT­YQ»ÛÛÛ$3ªì§–Še×F£Q:.œ³‹‹‹¬¢ãy$œ³õ¤MÞ ðÚ•µ­2¶~¿ŸõðEšÌ5ó¦VV’̬ú“=Í8ØÒ^ZŸ«9.ßüæ7cmm-+ÕèëŠÄngg'ßu0ÄÂÂB¼|ù2Z­ÖSì+ÞžÀükÐHI""–ÓcÓÑ€¢ªÏtÊ(··· ÄmLd˜€ ÈœMªd°kò_ÄDÿW+AÔ:Î6Öª)ŒˆdÍ€†á¬F~Öñ3À ÆîU™FÕ—“äTF1"ÒðÖÛ¤?¾‹9FhûmfÆÁý½—ûršQÒýY# @Ž*ÕñáÔÔ„1ïYùÁ`sç½BðµJRÄtuˆÅá$ê+ÏJjDç[„]ÓøÞ¥–ñäPaùD~êI ÆÞfËIàä˜ÇÇÇÙW~¯ e³ÙÌê9ŸÕÕÕ\3Ö”ñ1¨ Úœã*=ÃÎÚÄ £n]+•4Ímãf×*GU6%™Ôx™ctÌ÷÷÷±±±‘`Èóˆ&HÌäès<‹ˆ‰q5÷/..²_ÉÊÌ5ïíY«3g=y¿z2+›§€bs~¶Ö8›Ç†±Aî[™{`“îÙujĆsº¸89‰•¶>"2)¶öV«5•‹Ááhé'þŠVÎú¢Vú©zjvRBv»ÝN€ÌÙv-NK­~åÝô=y¢>%ý2jµ!:}¥9݃°þÙcÌ9©2ŸJŽÔ¤fkξÄ1Wõ¥Õje"6ÉfD$áU“¨ÍN‡~«äLÕî÷ûýŒ„à¢TœTû—¾Fjp>Ø k‘Ví–½C„ºÎÉhg#ROíÕjÍ_üÅ_üþüÏÿ<¾ïû¾ïÿïgyjÿµßøßˆˆHã†Á²Û…L›¢Ë†UüºÉcíAc“k5“‘Ä~ ù2îž ›Ž±®• ææær£\½]¥C ¦ÈÃ,øLüÌF.ô* j³²é·Z­¬ÖLÛô8;®•.OOOÓˆW'K•~~Œ©¾Ž˜hM=Ê-À–(ƒ(F¶‘ÏÞh4’ñµib\WVV²º‡ ÍrUo[ç ðaþ-//ç)59PKuëþ`ós€Ì&)„mÃwÏ 0«Þ¼=îý©›¥MÝ|“ð\] «Vál---e"œyÉQØÚÚJ'TUãÆ©q°úý~t:©0;9ÒþèWã¯ÿõ?ŒßþíïÈõ,‚P+Úø®õ까5=¿èE•] ýŠà¨QGë˜]áøŸe®†½ƒlŒÞž“OÉ ±9ýsss9O"bªD§þ3§ÙI²RKŸçÔ°ç‘ùPì©9XóZfí$[äâÈCÑ¢´ÆE[OöŸù‘‰§öêµ/}éKOÌüëÐê ]4.//§~µê ”ØÚÚVBØÑ†…q°‘¹– ¬–ÎŒ˜ÔXÇî3úF#ÙGI5Z`£ÆÖ†ÉÇ©‰êfT½G£19¹±²O1~ÆÞ1öúLBÔ¬N¾Û¬OÔ5·Yh¯)ÆÅfÁÁ¨À kÕ:N’ Úòòråž`¿b_Íq‰½œ^Ίœ÷FØ£iêI«”Ê”CRŠØYXXÈçÑWäF#K%ë§öê¶'0ÿš4 f¶jm¢60 ø: ÿ÷™ˆIé1Ƽ¶Y&§ê8+s Ï>7¦Èwª VÙÚªïôŒµ‚…¿½3æËû---e0Ö “1‘iU³Št»ûÓ(cÎfÙeш¥¥¥'aÓ:6Ào•(ÑuÛ,…­+ˆõ9ÏS# uÌU•¨ŒYÌÔ$?}]CÄ5”ë=<ëlùC`£ æ{€|Môò»»»»ÔÑëŒ/ÐkŽ×xœK÷¬¡jׯÈÖw7çgæ^˜¶ú¹š° lšãœ)›7–Ó`>Ôœ‹Ú?€ƒÏÕùnlýνêxÍÏÏÇßøÿeÜßßÇøÿ>""~æg~:ûàœŸe›zÒmí»Ú¿æÂx«qRÉÆØüäOþTü£ô?ÆÖÖâÔZ7ÇVë±Rʬ Àöz†êìÔ¶¿¿ŸÛUç—HCý^]»æ°¨&^³þgËpÛ±¨F›XnMÅ—zB4Mzíkd'ˆ—$Ül6ãððpÊ~xïí¼·=ËÿŽŽ¦"¢Ë¾_¸ÚØO¶Õ8™Oö!v¨Î©Z‘ȵêz«ë•üðö\îï„asšýmB¦è[ó¿æÕ½@tAÄéÑ?Èß©óõ©½zí Ì¿Q´Éj6ÀÛ@>ÁGLŒ%¶šÁ#ƒ©üŒùÄüü| ‡Ã¼Æl¸ùää$Þ4›zÕX»O DÄT•‘ˆ˜ª!Mš I̾w¨c-r1‰TígÕ7Ó¨êC€#dÓ²Ù ‡ÃŒ Ø`ÝGéG}Qž„À«ä¤–C$R7 ôïZUÃx{Œ6 pÄlœ²QÀ‹V¿ùùÇp°JdJôÓN9ÄVFDFmêFÅ3æ˜ÒªÕžã~}}=U†ÎØJ¡DI’ŸÅÅÅL&«›ªM½êÖWVVbqq1Žs<ÖZr/bRûÛIÞReRîoퟟçü&= »®´®}K¾gm4ñc?ö7£ÑhÄ¿ûwŸ‹ˆˆŸû¹Ÿ¥¥¥<ñ¸ÙlÆÞÞÞ€°FjÒ—/_fÔèÓGåˆÈh•õëý{~~>NNN¢ÛíF»ÝŽ›››©(W„™GÞ·æ>4ŒEDö“1'A³Î°Ê™>%‰œE‡Ì÷ª¿1³FƒAFm–——ãCúPŒÇÕ³<æßZ*E-õ;½·wS brv…(Íx<Žíííxã7âë_ÿzFÍ^Ĉ¤RsÒz‘0’=ëy ®177—s"&‡‚‘©Tû õžös•­eïkÒCEc4¥£Òh4²ä$Vß;".ØMc[Ár•Àípl<ƹÁ>°½“jc5òÍ1–[“µ­óûûûø³?û³˜ŸŸõõõ´?"ª¢®U“lÍ‹ˆI.ÙS{5Û˜ ZÕñÝß?/O €DLj)c[r¬2ò Îååe2 Â߀'þ¾¾>bkk+NOOÓˆ®¯¯çs‘VØ0jb&¶œ1¤·J1Ÿ®+ Xáu“­ìÆ `±is°Q¤#ž©Ví©I¶5¹sww7kW'ûX#N;ˆ”0œå¦åyŽŽRG ”*ÑçÚòj¢_•‰@OZnZV!cŸ¯za` {«jH=Qðñx<¥i­ Ë+++SšX‘ÎFet•µîjmoÒ¤óóó”†,//çi‰˜J€ÓXv»Ý<Ñ—NØÐ%ÿÞÝÝÅÆÆF^ÃqP‹Üœ Íkì«þ‡yðR-?è=ªlfii)+YÓÜÜÜ·•3uˆ”ù÷^ú÷*ÓúÙŸý™¸¿¿Ï}î·""âïý½_Iy yZåööv\^^ÆÙÙYødÉHfO{˜ä8 ÈG*¨r{½^:–­V+uÑdœ'ü² µ’ 2Á|ç0Äò~ò'*~ã7þ§ØØèÅ`0ˆf³N'ŽŽŽâèè(OVPkµZ©…><<Œv»‡Õq„%csz0åUßüÆoÄÎÎNÜÝÝÅüÁ¤m6îF#+Ǩþb^°ìïþþ~ÌÍ=–=>>N6z0ÄöövJ¢ØüˆGÇÃ96~U®"Ǧßï§c_Ï ¨É¾@¤\)óŽäêúú:666âÍ7ßœ’V'loo/‰Lºþð,l ½jîÉWNWWW9‡ë\¨2>ûy"gº&ÇjUÊ4§dT52ª/j‚»ýŒt‘ÔÍx"GVVVâƒü`ö¿5ÂÉCŒÔ”;öÝyj¯n{ó¯A«Œge“jRiDd"BèÐ&t}}F Pe!‘›j•7Ì–»¹¹Éça¸è_kŒH­TƒÝð<óóóYú ¸¯`GÅ,‰†y—üF"0{"¤šà€¾»qMd¤½7ƒìùýÿêê*ælœŒ³ÃCèÙ±6ý~?‡ûÍf3vvv¦ŽB?::J–Øx ýc“ªª†¯¼š0777—õŒ%‰\T¹IÕ¨*»X£ 5raa!«¿Ø8Ý¿2È~¤q€l\µü¡¹Ñl6³$›Û{Ö8L0¦ë0p8VWW“ ôy‡Þp 8 JÖ(ùñŽ<[»ÝΚää]€ †[ÉI µùD_]ed(æMDdžBĤ2ÐCÇñÎÿå_þ¥8;;‹õ¯“æüÇÿN,,<.e¾‡ÃìŸ*ɸ»»›bÿج+§ S*B5y“3RA30Œ™o6›i‹üŽ“fŒŒ™ÇìÙÍf3ŽŽŽRBC®+ _ß©×ëå8|ë[ßJ™ƒ9Éé0Þ÷÷÷ñòåËX__OgYî»quu/_¾L`W%6¢D½^oê 4Σ££´³æÝùùy ‡ÃtL”ÅΛî­Ô§÷~ùòe<þ‰®ÈyAF±wú>b"u©*6—³{vvN'÷ïTsتz¦‹w±›sæ<‰àl>ÚS{µÚ˜ šÅM0lŽÀfIxß&aÑüXØ8""“>i8±#@•kc¤É$lP5ɶê‘1#˜uLBcHŸŒ™•ä0vdQ¥Ä¦í}Ü‹ˆW׃SÚGÆ_՛Б1|lúHø@§·­Ìçx<ŽÍÍÍ)–¹F""ŸM¸ÚïùšL5Ërë'eÍ ›M•ÔgçTiPÇ™ÁvC}³¾¾½^/Ù<} LØœ*æ}¼·yK²a.ÈAÀžiUï}¿÷ND¬z½^2ñ@ÚÕÕUôz½y³Q“:>‘Ÿ»»»ËˆY? $:´ÌZ>::Ê1Ij·Ûq}}¡õáp˜,²(’¾‹˜Tvár ¯µ×ívcyy9~ìÇþf´ÛíøçÿüQSÿó?ÿs9ÌWëm<ÇÎÎN‚Ž à\ðQQˆdÃ8’ʇš1U xu]kÝ:æØsv0Ô«««y‚p£ÑÈÃÞêœÖGd®mþËûyxxˆ½½½|ÖÛÛÛèõzé\ôûý´$U¢(.a ‡Ã\Kœ±…áв‰ÖØýý}Zç ´*Ý;99ÉŠYö„ˆHFÙ\úÎïüÎ)™–¨ê¬|C.Ÿ­Ï‹0AF'ÛnooÇÅÅEüùŸÿylmmÅöövÎk€UO6®Äþc7Eµ8¼úÛg¶··ãàà £Au-V§Ü<è÷û1bcc#£Œr¡8<úÏxˆ\(ä°µµ•‘•ÌÞ}÷Ýxxxˆ888ˆÕÕÕX__/^ijgÏ2ZyzzšvËéÍ<ÑB÷d·=»ÄzÎ;›X×ÓS{õÚ˜ š„MlàUø3Û+Xô9,¿ ƒxrr’Œæ‘ѳÉ`UªÜG‰ÆõõõdÊHN„ƱO@²Æ!ÁØø|·ÛMf‡A¯%½×íím\\\¤Ö”¶9Õµ’Ž÷òNóóóS² ,6v·jxìœw‘ ëh“­!gr&¡ã¥¥¥899Égç8È[ÀºÏjI+‹Yå7òH§°Ú0ê…›ž»–º¬ ®Õ kôÊ×(M»&$W)Íh49ö½ßïçFGG.$ïó¤³#Pîùô9Ý:àÂ9õŒtÌJ–ºÞÝÝÝ”‹Uäœ`ZÍ3ýÌa$‰kÂ[DLEp°„¤6æ'ÉgÍy'žÏu Ô¯üÊ/Çõõu|ö³ÿ,""~ñ!Ùæ³³³h6›±¾¾žì/']ýq¬>1‘²ÕÊ.Õ>YúÖ<\\|<üˆ£{tt”ÎÇýýtIR@H¤Ì]ùñÿ‰ø—ÿò·ãèè0ICý²wo?¶®×YàGÍšu®UU³Žk¯½½M,D$Rn¸à¶otˆ–pâÄvâÄÎ&ާB‡ŽƒEðQñ!>%$€þ#¸¢M[ŠDïd{{ê<ë\5«ª/Ê¿w>szGÝR ѬUŸ´´ÖªšóûÞï=Œ÷ÏxÆxEÄÒyRöÓjþúŒˆ!Í½Ïæv¿ªjã–•IÌ“µµµÇT„)k“^ Xpvú ­ädUµµGz–1v_PËn8ûÀɰƒÁ0é]²¬èÏââbGå5É–äYKqàÝ«Û펼¾ïúúz³ÇÇǵ´´4’p2³Æ<ÛÄÆcí9—">œ0¹B)±²N§¦†g¶˜ 333ÍéijÙT§Kg”C;UÆrû$‰9ß)‰;ebï¯÷ºó/Á• O6V,”KˆÂɯ¶"“?õy ¿ (ÁG2XÆ-õ½j&;À ¤ã—7žÄ“rŸªj• \4€%‰ˆ$©4p<€iÃÍj(UÕêa”=Ã÷2ZaiÎŽM8ó3l¢P6ÖߦxqqÑžëëëvì;)`Ÿl.ômŽ.óB{m Uãâ%¤Ù˜3ºb>˜K6b qww·Í•ñ05ös–ø<>>nuÙ3$Y¬ªjL˜äVŽ[ޝñK ì÷$AH¸HUÖ…?::jÉkÙ‡Uà 6ØJk-Á´>áq899©^¯×Ö«d_›µùËÉ2wD•y÷ÞØØhl.)Óññqs ­ JN f¯ÛíÖ/üÂ?¨ªªÏ~öãUUõ±ýlsÏ’û á8%F¨ªjëÝ»LOO×öövsR>ý¤¯Es€!Q@¶Š#ÅÞq®»ge[èè»Ýn=yò¤E¤¬Qcì¥Såžé˜g´qeee˜÷z½öÀ" ­?Œ’uîâœëÖe’¾oHb7‡jcc£ÙnµÑ%oZÿäiÈíDÙOƒA‹Æ˜ç¢ YŠ8×’}FžÂGß;$Í–G³“òt’ä0—«îjóûÝõõuKdO»§’ŒÈPÕ]ôjgg§666ÚüÚÜܬ7ß|³&&&ª×ëU¿ß¯^¯×*^áI ™_ìKÊÎ2"lˆ’9ó"‰129û§½€]1ßí‹KKK­ïÔß¿¿^ÌëÌ¿$W•¬õœ,¬Ÿc]Yðð}›W²ÂY¡ÄMOO„5ówîƒáÊÓiÈv¹%àÖ5þóžØŒÔeç…!TIÅ{ËHYKn~ã’‰,ñɈc ´IÒ€â3™Ï`“o¯±LÝ«ö¦æ:õâÙjhs>‘”æ¸ô€â}ôgÕ°‚ ‘cà^ÞM;9MªdýìÁ`0D]" ÆÃ\x§Ïw»Ý&›Êïë[N‰±ÌK5öžÓdÜ86òö{`;k~»2OÀ˜qZUn±nô7©CJ¬è†3’&ÉØXpàŒ­õT¥³Š‰ÕoÞsaa¡ž?^ùȇ«ÛíÖ§?ýɪªúÛûoµö=}ú´NNNêÝï~w«8SUm\”4.ÀÏ‘“Œƒ@DAJBªî@[Ö+çÈ™©sŠ'&&ê}ïûÑú½ßûݪúÞóÌo}•ŽgÔ|õI9Ÿw•ÈNeMxŽwËù(ª&b’9J»q³–TÝ!'ô‡6Ü4Ÿ€Cy!îmnù<§ Ç.í^Õˆ_]]m2”~¿_-yYô”ó{Ê`pw6AVÃá¼óçççu||<’§ g$e–Ö¬yŸ5×µ9mIΟL¤OàoýoŽé9YÝn·I»ªª9œ7L¾1×NÏäTgÞþ­fGr,H©Ú)±’Çßõþz±®{0ÿ\ xÕ݉ž¹áeØš1¬tX16’Øy I_˜E,p€ú{yy¹±å€cC– QÓå=mV˜gŽSU5§îðð°VVVF$r=²ý@¶›†;£^€6Y ‰Ãä)p‚yËÄB Èœét:­<Þòòrc^éjÕG÷Ç¡M-y1ç0UU+§ÏŒ‘¿¶›¹ IDATûý~‹­®®6Fóüü¼vww›üL{êŸü“_®ÙÙÙúùŸÿÛUUõÏÿùoTÕðtß………êõzm,9ÉšsÖ2a¨Qüöö¶9‚§Œþ°)òCÌ©t\;NýÜÏý­úÊW¾\§§wšîõõõ‘ê+ÖöþþþûÊù3GågdÉÉ”=™/µ¶¶ÖsŽïÉÉI³Y¾c~]^^Öêêj;L/#¶æææfÄAêt:­<äÙÙYÓV;ÄN¦£££&»êv»µµµÕæ…>4Y,•sŒZâ-Â…½0¾Ú;99Y?nY¥9eΓ[qˆVWWpÖ_œŒdÉ_¹)’1Ô¢×”|Zl½DçÙÙÙv.Èòòr½ýöÛÍæ;×¹R5<¥ùÏü™?SÇÇÇuzzÚÖu&xw»Ý–›’R±™™á™ú>£«"(¯,l`|ìµö–ŒHÞ_/Þuæ_‚+Á8vˆTp›b²Ì€‡pn–àR8öù¼ š¥áò÷6\ìRÕ°œ&fž¡J60K0”e.I€8†´ª¾§­Â´6£t €>¬8y@.Êý cõ%ãV eEï– ° l=ST@‚!&Ìý½ö9ó²BÀâ»)ƒDfŒR‡¬-ù6Ïœc†úÿÀ@æbЖbb3â`ÊP»ï`µ‹ƒ“%>E"ò0.8©);!£rÿÜìµË½3/!A…ùcÚ¨9¸™'’•t¦¦¦Zrd·ÛmGÖW O;6f*Í-N™$c}œ}”zïÌ¡ÐO™Óív›Nß\âèJ®ÃZsÖRÂññÿJÝÞÞÖ/üÂÏUUÕ'>ñOÛýÉ[Œ©¿½¯H¾Æ•”ª9œi|}»/öøôô´EmRZÇÆÑæ§co^VUs\=QN%p9ÓôôÆ+¥T †%µë?L2çÃXsˆE‡²Z g•¾#ÏFˆèe 甽bCÍ}Ušvwwø%§9>>nk[¤+sDoÙËÈÒ¬Qò(ë‘MêÓ¶²íéŒ#AØë‰ æðgKs $WdqqqäTݪ»ˆàÞÞÞHE7ÏåìË]á²#¢"ì½j?ì}Òœd“=W±)É ë—KâfkkkDŽcú͇”àÝ_/Þuæ_’ 3ž›Ž+¤ð·ª£­ÿªaRj2¼_¬)†z0´p~²ÊUÕ˜BF·ªšaÊ”³™2ž˜OlRU5æÁfn”Úx«ªVWWÃ’T “EmòUÕ6ó<ì£Ó¹«/ŒµL„#Õ±ü ò|_7²ª¢#yÙ0H:—––ZÉLm&oÙ°ÙÆßÏ<Èaðs`4ccccäwÚœzxï‹ý7žÃq2ŽYÞÐ{`4U:??¯Æ6k,/¹ƒù¨š¶MßÙØx›Ú甩æ9i®WÕHõ&a} $ó<¬rUTÿÙÙYKLVH60vªùäÜ„­ ²1óÜú_ƒÁ¨ÎDC[&áb‡EÀ0¢¢3yR5ÇC¿NNN6‡“¯* »Æ‰°ýÎaTéØpæææZ2¹¹hœÈe¦§§ëéÓ§í´aQ83fOÍÌÌ´j<Þ+pN£ùžå]EY´3OŒ¶Ž=[¸ªÚh;;;MV¦ÌqVý±N8F˜r§Äj+‡K2pÕè)¬Y4òn·Û’D±îŠhçÄÄDíìì4ƒLbj~°±l¹ŸYGòØ#½Œ~§Líòò²U™Ê’²ˆÓi’ŒŸÒË´k÷׋y݃ù—àÊ’ZÀPÕc€¹q`ƒÍÄ–56ååååz×»ÞU{{{urrÒjgbç‘#AYMÁeóð»×^{­µ‹Ô±Yò 3I _Uí].PÏÏÏ·ì@/‡È0l4ÒʯU Á ÖÛf"¿´´Ô˜” gå}¬\&™aÑ=§¨x‘¨–+ªÐv·Ûm€ÿôô´noo[• Äø ÓW “ßü­Ò©T·Û­¥¥¥æô˜(µ¥WWWˆçÙp395«h`¦€'‰~ç;ßis¼żŠü`#E>ÛœžT«lfŽÙHEŽHª†@c~~¾9’€´¹’N ÐÌÑQýEâ\Ö@×¶n÷îbó;õÙîUUÍá1ž<¨ããã6/<øJ`t©^r||\«««™ÍÄ@N‹11Îò_üÅ_hLÿßý»«ªªÏ}î³U5z@›1±>”‰ŠDŸ|‡¶=/ã DrªS†Ã`À_{íµ6–SSSõäÉ“–‡b^^^6 °fÞ°XaŽu%,îl# ÷ääd­­­}OäMÒ,' ëÌIÎdukùð𰦧§ëðð°Þõ®w5[ªê °G:xyyYOžØùªaŘª1F6œª!sgÚÍ“î¼ßÍÍMíííÕÚÚZcb0I }^ÔûÙ¸¼·ˆD–aó<%ë8!6}÷ðþ\ýâè³ÊM:É~{®÷¨‚#À#f\mµ•õN6ëlKÕ3#IМ …€Tˆ^ش͹Á`ÐÀÂÙÙÙHíh@Zi6s“I²®w¹¹¹iNcUµWh[SoŒ¤$ËÜRj 2O8NÀ¬ß˜f³”ðøÓ«›c9.Æ´Aé9`ÒØ3Êã2¿9}ƒÁ Õ³öþ¢ UÃs'RÆ$ÛMR°¾¾Þò&sóÄ\¯ºK¶#Àæf‚÷§?ý©êõzõÓ?ý¾ªªúÔ§>Ù¼ååå&ãK@n\ƒ»\‚ƒƒƒzQ‚Sù)'ìt:õÞ÷þp}ñ‹_¨ÙÙÉ–ä/7âððpäP¶ì_s„ã¶¿¿ßÆD[ÙA`ˆ”ûÀÁ•”˜y;úÀ³Ró'•tÚ½+|vvV¯¿þzcàEgÌ1ßeÀk.‹Lä‚Öà›É–‚ÇÇ£íó¤]™|žI­#¥,9ðØe’‘ªjŽ9‰žþb³æææÚûIæöïùȇ¬ó/"PUÍVr¨8JæDж°°ÐH c§ÀЭÏ|^žH–ît:°xðàAíîî6{„$àè ›ž?^sssíi¶æââ¢I\Sru½˜Wçÿù#÷×ÿèÀ¿ƒÔuº°÷6{Þ'¿Gj’ÿOƒÇhå=\ùs%ÕH!$G· 2þ;÷â(Ó<À™”™ ŒXc×äähÙ²|Çq–YŸæg\©ãµáë9ùYí“ÄèsãýåžXRïéÏxHuüÿÝn·96•ñq²¡zŽßgÿ{§wzO¿÷ÙûŒH”HÆñɤ´ñwIÀI+ŒíÊþ½¾¾¹'æÙïµU§¶V¿ròÆûÏÎR¾c”•c5>o½‹ù*yRD!ïëÙæ<Ÿ`¼]Ø[ëÀwE¯r<´ÃØfm¶/Ë|úž¾=±–õ|åËõ¹Ï}¶>úÑŸ­÷¿ÿß³.Œ9¦ÓØUÕH™Å\‡Æ,I‹\Ÿ©?Ní0‡¾{ii©­e¶F[|fmmm$Ñ_›%?š×Ù¿wõÀ­em%¥,}7çQæäïLÿ¡ÜÛÛk}—ÏÈËw$nŠÜ¥]M;”ùÙ·igsíW Ï0Hû Ï<Ó¾”DŽ¯Ë¸Œ÷Gþ1ÿÇß7×aV~ñ`Úú².ìkú1£ÒùîþýNûûz®vÙÛÒn’p¦M§=;ívÎWk½j¸6ï¯÷ºgæ_‚KÒ’ò\ΰš 6Uˆîôôt¤t×ÌÌL “5`It„â«îŒ³dÖ~¿ßRkšÌ1Ã8ÎFkOV}ñ}̻Х¤#L³°ùíím­¯¯7 \5ÔZKdzM½n–ç̶ Éc]2qÉó}nqq±&&&0HÙV,«=`6±q~žúVq2€ªaMñ<í7uÌUÕd%L4&;›µ›…ôƒÁHb°ñ"¢Ûm 'ÓÑ$%> èmnnŽ„ˆ\ãÙY}%#+Âï¾+±S;Ì/@Ì:Ð&ò 󑦕,Ëfk¬3ñ,#™Ll~÷z½ös}^UaµînooÛºì÷ûuyyÙBïÊš—˜[ zsà2%f)/ÉW’¯ÌÍ0ßR_Ûï÷ÛÜÄì럔^ä˜Ïž=‘ÑUU={ö¬U¹ººª/|áóuuuUo¼ñ¡ªªúò—k„UÐ/˜Ø½½½V‹^;·¶¶ZYƪ¡“!Yóúúº>ò‘Ÿ®ßû½ß­ÉÉÛÚÝÝmZçÌÃɺìœü”‹Ð–ïl„uœOLLÔêêjs8°¦"¹ñ^)ÓÀîNLLÔÁÁA«~}}Ýò®¯¯›ý½½½;ÑùÑ£GMZ(ƒÚß߯ÅÅÅzúôiËo‘´üꫯ6ɤùa-˜ßSSSµ²²RÓÓÓ½f¿=ýv&¼›ßîM_U­¼ëÔÔT;™Ö|!MSÌàðð°åAé?ÑS‘Ee‡í’d³Ô®H(ÈÖÖVý©?õ§ê[ßúVœœÔÁÁA-..6)Ûƒjoo¯­?ãæb7onnjww·­yÚúåå呄؉‰‰vR²H˜œ±Lb—0ÎÆ³ö[¶°°ÐìPFÐE¬éýõâ^÷`þ%¸,îLÎJmŸD/Ú`‰ 0 l@YÛ›qJÆŠÐ"™4€@90¼ººÚBÏVö9›J2«ª"h XU͈{n&IV +LTUÓž %»¿rcB¸´¯<¨~¿ßt”Bð ®û’¾ýWÕHé6€+å ºÈŒ]:ÂÛ©¿öÏÇ…)"²aäé‹À?9б²Isè W2c Ú³ê‚ß3’8s̼{ö_nbœò,IÀÙ×$dæ Ond¤l2™ç!¿CçKºC¯ë~ÛÛÛm\Ò MVXý½½½ ­" ‰ ‡áöö¶•ÔÖÙÙÙ‘ËÅÅÅzõÕWkaa¡~ÿ÷¿­Ùª!‹xyy9Ré„l…–4÷T÷X^^nµæ3é<ëeKÖ$a8>>n Ø¿ª;Gc{{»ÍÅ'?ù/ªÛíÖoüxUÝÉoö÷÷kcc£ÕðWâðêêªõ§ðévïêYZZ©3rrÒ’¶Ù’̽`?²´èÅÅE­¯¯·u§_Òy!yáHª ;iTŸI •£`¾æ=¬Ë^¯×æüÇÛ8’†TÝÙõ,#ì]TcëSoŸÎYÊD*se.DžŒšö¬Ûí¶{¦}[XX¨~¿ßÊcfÄ ÛlŽv»ÝöìóóóêõzmÎðZàݳéÝ766Ñ€°¯å l òáÑ£GõèÑ£:>>®çÏŸ×ÌÌÝI®rˆÒvú¨äTU KÂÒãúùééi-..6ýúÊÊJsZÒ^¯×t¹Öçþþ~‹´ÐDïìì´yðüùó¦±WÕ¦j(ñùü糪ª>úÑWUÕ¯þêÇ[ž† /¢Hy@—È'M_OLL4úÞ÷þp}îsŸ­ÛÛ³–,í]EH$4аa½éÈwww›¬„Ýâ,>zô¨9Ûú8úþþ~³{òd¯1Ç’Žy‚H¨ªÚÞÞnD@–ižžn•쑃ƒƒqüÎw¾S½^¯VVVZ ù""{||\›››#Î@’˜÷$l¦§§k{{»d/--µèƒÐúý~½úꫵ¸¸Ør[ô›>55U½^¯Ùg•bähx/ÑBßñÎOŸ>m`\D.«V‘­ÜÞÞÖ›o¾Y;;;õôéÓ–í%I>œŸŸ·½accc„I×NÎŽ9àKÂÞÙÙ)|}}]ý~¿ÎÎÎZ®bfbb¢1óòr:N;«à•W^©åååzüøq={ö¬‘kõ•7dÝ3ó/öuæ_’+æî¡ÜX$>å,=ƒ `ùÛ%ûßæ„½˜U<,léy¶ÙsÓþåœËˆdæ xÔtë$Œ±F2T ¥&‹‹‹ÍÙȨ¹¦õŸ}ɶOòöŠ.½ªF¢ŒœùÜ3òñ*-ú›ÝŽM)}öìYžž¶“ÑÝ 7ö™¬_[¹‡Yûª?/— cùYs!Kþ²Ýlâë•W^iûoΉLvµ¿'át½¸×=˜ .ãÆ`eY®óóóCL§Q·™UÖÈ®ª¶ŸN§iŠml˜ ¥Ól|´ þ÷²÷A̱ït:ZZZjFñææ¦iŽ•¹Kº0=&nffx Š0vjùW ) FÜÆÆ¹Á}è? ‡6mÏ×€\Uµ’ˆ¹ GNwNý¸öaÆizõ #ŸR%N]n|©s&iÐÝî°¢CV3¹/=å&œ f›¬’¢æy€Ñ&‰ÀI<èj9éà˜s æóðÏå\z}²¾¾ÞápýXUmO,ÃDÒ•ÊáÈœ¶9¥8Gj3×ÀÜà,Ö¿ÿ÷ÿ¾.//k{{»ï™9*æ£{Š4ÕêêjâWWWõàÁƒ–X999Y T=xð ¶··k{{»Íyò¬hæ/˜{{{8ŠôÝÊÊJœœÔg>óé õ±ýTUU}õ«_iöÇ÷ÈÞ°ó $åïüȼ¯¾üåߪëë“ÖÇ*Í`DåøäùdÖYKUÕúúzcN–ûúúº9GŸœéèè¨éçå dTÉõ¡M´ø’~=ßøÐ—cÝWVVÚe?Gì¾µ®Š‡·ßïäF‰ÊYóÆAE‘W óÖ*[µ±±Qý~¿z½^7»µµÕ$gæ¾1e/0*•e¾‚Š=ª‰Bˆj°ýú½=>>n‘Ñ35ú¿ÿû¿¿...Z{FV^J¢Hõ›ãããÙ#uòs¶^õ2ù]Ýn·^}õÕ‡ÑiêÚw}}]+++#ùMúìææ.·Ke0Qû0~ÚÏûëżîÁüKpñÚ™ª!ƒ– PU5ƒ|`“lRŒ‚ Ðç]Xnì¼ÍÖD,3#  øãžUÓó™O×ôôtýäO~ ªª¾ò•/×ÜÜ\›ÃtߘrR†ñÒ¢´ÔØy‘5Ä/..¶R¡)²vwã¢_Ì÷M¦w¿677kaa¡ö÷÷›´e~~¾EÌåzŠ$3¿±±Ñ@œy`­¶àì쬑' à<.—­d«¼õ‚Œ`ϬkÑ0çSøy:¦333õøñã–Ì;55Õ€tžXëÜ“ƒƒƒ6¾ú×s¯®î:3§ÈOسÁஊBÀú·ÆÌï«ß>|XƒÁ õmÎÛ<¹–}ÍT3#Ùæ7Ç€ÃPUÍVä~Aú÷ðáöX®ýýý¶ÞD ¬OÎFÕ]l~~¾I·ÒÞß_/æuæ_’+^afÆ"A~ÕPSȈ [cªê{˜üñ猗+#a «jÄHeÉ»¼#މÇöe8?Á?Ãí>ÙÎl“gÂ)™ÈÐp†…màŒ$Ö„c£Ï²/óÝRäù6µÜ@l€ùn«’ Ã>Ÿ9 9&6—ñ‹S‡  ´=dãò÷Î2ˆÞ + œe²l‚màœdÛówÆ ®¶ŒÏ;c8^Ê͸æz0¾þäœÉä1 ]J-²,£ÿsVlòÚëßÔçN`ISöŽdö*×ÐçtÉíÐF^¬s–­ô«KTŠF:•>V_[ŽBöK§ÓiNW:£¢&±ó˜]íЯ¯¯ëóŸÿÍ õƬªª/}é‹­8Â777-òp~~^?ó3­/}é‹Õé çÆ;Ù¼”°™ìˆU­ªZ[[k@)5äiÌ…™™™æd¢4ƒÁ EòrÎÏYýúüùóÚÚÚj2|Ûìûˆ¬}Ê‹D”¬5öeÜñîv»í„\Qˆñ+ÇKNÁôôt«†¤-æ—*diW3ŠVUMö’ïðêNPEroÈwóG¤%I+W•$\ ã–<÷ív‡åFOOOÛws-fDÄRgl:Û%]äQ?’<îîî6Ïêt‰êÿ$¼î¯ïºó/Áh%¸ÁräFÅäáN¬³Qaoh«?åÛ¬rոŦºoêm±UÃ0-Æ=5øÂÕØaP¬ªŽ&Á9<<¬“““ZYY‘ì d(´Ê¢J;ÒiºŸg`„½½+–>C²Ø3Ì–'Yê!…e|9 @Q&–Úx³~²‘¤~Ôý€ÏÅÖUUÛ°„ª?ÌrÕÐY"P‚ÓÿUQï••2BRUí[‡¾Ð¹rä²äæ8“˜ò`8+>T Áˆç///7&Ûšê6%¤š/2+s@Ô_;zÍyc‘g ø}&üY‹KKK# ØZä›aô0’YýÅÚ&VVV»þÊ+¯´5n\< ³k~Џ=xð æææêàà Eƒ2w#œ¶™·+++í}mm­­ªjÑ‹‹‹‹VVvbb¢¾øÅ/ÔÅÅEýÍ¿yWÒò _øüHéGòN”ŠE§§§íà8s’~}vv¶U`í ‡Ä–——kkk«fggëOü‰?Ñ$#GGGõüùózþüyõûýªºcFɧȘnnnFr+H2r-‰‘8f´K›$6scíóÖTUÕææfÐɰƒ!ù1ÖìŸCŽÈš€èËËËöl ÖÚ-¶=æPg{̤‚JbÖ>æ^ÎÅüü|žžŽä4égÕt2w µöé,s’t‘$3ØB‰µ¸¬UU-¢•9×××ÕëõF$•ÖQÕ¨ŒYæÝäiMNN6Y˜yâ¾Ñd›è½Ó‘»¿^Ìkò7ÞøÇo½õVýÀüÀï¶Ü_ÿ®O}êS#!íªá1÷XB€âêꪅ9m@#Ô9ÎDÑäb#Zjšil$甃ÎJÉVÓ›j–zcl%ßbYR¢ŒÏBí6<íÆÎd¡iÓXÛhn}Š9¬2âUÃ*.Y³E0ÇØºL”µn‘£ª;©ÍéééHò`j˜³2襁ø[N§9¤6{’3›¾ J曲|UÃÊ-æ§6ª“ëR¿ôûýzøðacç3ÚbÍcïÁ©Ñ?ìY¶Ñ|UñƒT'£™­mÿîßýOõoüåúð‡?RöÏþ›úæ7¨õá¤>ó™O·¾f«ô5GHÊüëÏ{‰¯¿þz­¯¯×«¯¾Ú*¶pÚȲ²Ä¯¹æïdONNªßï€Q¶O~’õ’ó%+ðLLLî'î IDATÔööv“AÀœC•\ŒUÎ{¹9"{is¬çd¶9»ôÙœK¹H···-‡ÂüÈj2öÎežïaMY#ì]zF¥¬ÙÅÅÅæ¨¨J¦R{’ò­œƒ)s±¾DK‘ƒÁ 9$IXeâ¶¼dòåXxÆââb#‹D$TøAŒ]\\4g}ff¦Ýƒl3m¦<ÕØ/Ž»›Eþâ_ü‹u½x×7¾ñ{fþe¸ ƒä«ÙÙÙ:88h›¯Ÿ—ŒäÂÐ2ú@b2£U5¢Ë´1ù7©FU$I1RyXP2¾d-UÕ –ʲWýFxÌ* ìcﱓÀw–[ÓNUÅ´äÉ™™™fl•ÎÃdVUíìì4 ´¾O-½~²Iê﬽YáÇf¬ß°ˆt³™ð…^XXh%Þ `É;¦fy}}½±­60VÉóòp÷?88hŽC2ð6Aìmp&™z7Î_F€R“ $9àEØÚfì½T›àüHþÐ%‘ypš°tÂ忝M8õþ¤6÷ÌwÐ8³®€SÌòééiMOO·yÙÔvÕ{8— f[ÉHàl~~¾ý<#˜j‡/qv½ $JT5zà”gKÔ³.Œ‘ùç>.6Èút8 ÒèàÓ1ÄΦ#ð[¿õ¥š­|àGªêŽ©7—¼KVqÀŽ÷å8Xß)ÇA lnnÖææf+  ÕÜÜ\ÍÏÏ׫¯¾Ú¤4HÎ&;´··×"?‡‡‡í»)ë“çÀ={ö¬õ1{Êy»½½­×^{­9j»'«ÅO‰‡L$hÜᘛ›«ÕÕÕªºÐ@µ9ëL„£££VÛ¿ê.Šb=ºØ'÷·N‘ úÛ­Ï’màÄTÝ9§¾cÝ›" ˜ª¡œN™GÄ…9·¦ãüy ¹C4! ŒËÒÒRÝÞÞÖÖÖVUÝ•Ë<::jkÕ!ˆfÏŸ<ß Cö™ã¢þîßû{õÿæúø¯üJçn÷.Ñ“¼%Ymíñ.©ò®SSSµ¿¿_¿ú«¯………úèGïªß|ñ‹_¨››ËÆJ§Í1.ãìéÙÙY«±¯f»vµÊ#ló6õï¹±µvSîÈá`ŸÌa6G{§§§[²¹qàPpjÍ¥åååVmJ›< Nº£­ã‘JÄA®¹œW2’•LŠw/gDpµ/ç{œÕˆÆ£/>7777’|Í>‰ˆ’j"ª8IUÕ¤’777#nô‡½,KÏ#Ñ/ÿéûì¥wñó©©»Sm½{îuœUk”“nm§&Þ•r£¼Ø÷ÖŽtšVWWÿØ·ûëŹîÁüKpÑYªžPu—˜=iÌ„) u»ÝÚÛÛÑC&ÛŠIP@îÀq \|73ЕaK ,à Ða±ûYIA8’N–€Y«&mVUû~·Ûm Lߤ£jÈÜ|JÃ>;;Û±ŽUÕ 3±Ö¦‚C2ê ¿’m€W¥Œ”µa—onnjii©ö÷÷kmm­J¶ÑøgžÉÚÚÚH¤HG^J·{WÆQ{ÎÏÏëàà`$Òhî±sikwwwkuuµ&''[ŸUÝ9-NÉż¯®®6F^d&ÛëR’èÀöövíîîÖÚÚZ“IÚéþ§§‡‡ï¹Ø‹ãããÚÛÛ«³³³–«À™›ššªÕÕÕ9Ýûúúz“ ’¼é9KöÃÃÃZXXh{XîKæIUµwf[ï¯÷ºó/Á`”„W«†‡¦7É@ÎX„^¯×´£Ø.Êg“µ«ªf˜€x3æ@F§j(‡Ž1Æ;ÛÒ@%S•Àö×¾‹ ÅRb?±GË’õ°‰c£ˆƒZ\\lN“p~²Ù’ÌH%²´¦{ØØ0x>öŒ,Ç&•Õkò}ž¬ì@ë¯ý)穪–tå½u%ó”“L†È$áp©wíÙ333aÌê9˜3¸ù`Nx·¬æ`¬:NÓlûF‚5à†]ó.êjkóÔÔT!ÖpB¶0ÎJ¸%c3~ú^­sN”÷ÛÚÚ©—Ÿ­¨g(¥’Þ2™—T¦Û½+wôQrJ¬ ëÁxÑNçôÛÛÛ555ÕØcíÞØØ¨ÿõ—¹ñ/ý£4â\53~2¦Q·Û­/~á M®PUõó?÷síž_øüçómž]EÉhí¶ygý`·ÍëÁà.áSr|§Ó©?÷çþ\u»Ýúÿá?´9€eÃÇ×ÅÅE½ûÝïn¹;;;õGôGí„[kycc£Þýîw·’”‡óóózòäI³EúId‘Ö][Ç£ëëë#špï-R´®¾Œê#l3›ŸUuüNXëgggMŠI*›››«ýýýñüö·¿Ýò1&''ÛÞ!Új½x¶S–“•G\lnn~Oõææ¦Þ~ûízôèQÓ/;ÊÉ®Ø8 ;ùôéÓZZZj>‰]jÚå‚ౕìȃêðð°í!333#§‚ëWN—è y¦¾1kkkõøñ㺹¹i†Râ#™Öz5¯‘¹K÷׋w݃ù—ࢋ¯ªfè&šôN§Óʺù|VFÀˆ*‡W5}—Lúé—Ú|<{ü¸9Æ{{»É@suqq±ãÛÛÛ-ø_ÿõ:;;«¥¥¥ú™Ÿº“É|í«_mlýÆÆFc09”Úutt4â dbxFÊD%•‚%zòäIÝÜÜÔÊÊJ­®®ÖîînUUÓ"{ îãÇk{{»^ýõzúôiKÄ·öä„ÌÌÌT¿ßo%g÷ööZòèééi_"‰Üíím­¬¬´ê1IxÿðàÁˆ\$î<Á%š¡Ÿ8æºì•••VçŸ#ŒåŸŸo¬´œ%Ò2:qsÑó3 ¹··W“““h‘€äÉÑÑшœÕÑ0ÍÆsmm­Eq J=²—l({ˆh‘3aÎË ÿòNú 311Ѥš®ýýýV¶X.ÖÄÄD{?sŠÜ'`É×ÊbÎÍÍÕÖÖV½ë]ïª÷¼ç=õŸÿó®?üÃ?l{½xbbbä—tŽä†Ù‹ØüûëżîÁüKr1ZØEF#«kŒ‚d{«†zî¼l@ƒ'å*YAÆ&R5Z÷=b^˜¼Ô!n@UV¡yo›÷ÈŸùnUµ¤8mtÿÔ7c£2TëÞé,9Ú¾0¼|φ’÷Ò¦Ô¤g¥@Pÿ’eŒë909®Y!Ç€N9•ŸûwF 2‚íõ|Ÿ×|ÊæaJJl¤Æ7eZãóMç\È1Ãviç¸L,ÿ]U-oB{3ºôNyØxíÏ÷[[[‰r¹©—‡,qpSRà¾ÞÃýô1ÆØïý­o³¯R÷;ÞîkãÄA›œœ¬Ï~îsUUõÆOÿôÝϾ+qpðyUžà™¶»Ÿ}† %ß ï¨ªúÜg?[×××õ3ïUU}é‹wõä3Êäÿ))Àfg‚qεñªIÆíÙ³g äé³Ô°»²,¬dF•„2)ܘ•Nôôo Ÿ¢ ¹–E 8ß)WÒ^ÀÐ\K‡swww¤úU– M›Ì^ç|på=½3Û¡²RÎqí¨%y[‘Éúžï>ì"§ÛøŒ“úÊ÷H8å h«qç`ŸoÂ9Ë„çÿÜûi_í1Yù hv{¹g^Ø#sÎ-¶Êï———kyy¹677ëÍ7ßlŸMY?ËËË533Óò%ÎÏÏkyyyd¹¿^ìë~„_‚+“nòp#àhÂ``!lJãúߪjZ^0®b&aJµ)% UC¶X“„”'”žœœ´ ¥jÈ>dÒ.†ÃŒõ¬ªÆ˜aXlÚÀÕÆÆFcڱ݀g–ØÄ.iöà /fv}}]kkkM:"ªêŽ=¼½½­ÝÝÝføõ¯ÃNôaJq\66Î~Å.iC·{—¬fÌǪjŸK;V74ð­?³Î2 žI$>ÆÅFo,Æ“ •ž3†ä0æF"B&S5<¹3A“ =e¤)ÊáÙ`ŽŽÚ8åaO©¶ŽÆ»ªjt›º™ñ¦µtlÈNhµžÈgÆ%GYÎQIÅ£££ÚÛÛ«¹¹¹VAÃ=Ilöë¦ÛíÖÿö+¿RUUÿð±–¿ë,³ ÂøúÈÚ6‡aV¾Yñy2Fε õÕ¯|¥ÞÿÔO|èCõ•/¹õ¡y&ʘ òWWWµ²²2’¬ë÷œMmý~¿9iÆLTÉ)¶Ö†çÌÎÎÖ·¾õ­Æ³eÞ©×ë5yÖîîn;Q—ãûž÷¼§ž{œ&}Æ98??¯•••¶ûý~Mc½½½=2ÇIf̉ù;¿Sý~¿>òÁÖ—ë·¨¾­µ¬$B]Uí¹ÞÙ÷3qÛÚà(¼ûÝï®Á`POŸ>mc‘öËû÷z½ÚÙÙißÃðr¸”í¼¼¼¬§OŸ6Ç|kk«úý~½úê«u||ÜäÆNtãöö¶éúÓFÍÏÏ·ùcL­mG19¡8všs«Léììl³W)«ã˜ë/{g©`MpT¨1f¹¾³º òi0 Z~ÇÊÜ[XXhÑNµÛ%i+÷i°æ¤u¦t®È´ögöŘÚ+\ƒÁ Ö××›ýЮÉÉ»¡Ö®9©ª‘úÕ Íý½½úæ7¿YßøÆ7ªªZÞƒÙÁ`Xå'5ýIŠ»Ìƒº¿^Ìë~t_‚ËfPU­R‚Ã"gpj†®êø2ɲ¹·ð ûØT=› Ð f˜5õ|Ú•(%À{²œ~WUM"'8âu¥Ñ·9ë«ñ´ïé3 €á礤^p×üW†¸=Ë»dûUD*݈§[weÞÃíímNGÊw2‰Ì¼H:Þ^’ W†ú±Ìù]awºi}ðå… ®ªöÞKßñ< Ab©ûêƒ|" î!y.:ïÎð¤MtÆY…D[RŽÀ¡6·<ÇßæZUµõ™ ?à|ç3àØÜÈJ(Àƒïåz5V‡‡‡õÉO}ª~ö£m¸\ µ¼¼Üª˜Ðñc¢ÓŽhg-uà í@ª¬ÚCŸR«¯~å+õÁÿñ¶ö±˜é¨û®“f])˲¶ÌI}Ÿ¹Ö˜yágùN97ªjdþ+ËÈ™Š{½^s4ÕR¯ê³1ÔÆ’óšvŒcb=‰À¸|†ÓáئŒª¸¿6Úœ2ïç3GGGm휞ž6°ª2‘ÜúPE Óm®Xèóóó–+bMy/d‰1å”K'ÔŠÀZ§IDÉe`¯E;’Ü@Îh[·{wâîÂÂBmmmµ{ÏŒxäž"¿ÂïŒqÎMãÍ©4n¢ú`gg§¶··›câw¹¶üÜÉÑ)ù²‡Úï¯÷ºgæ_’+ÃÊ)ñïªj,1,Žkjú'Ož4†›T5Ü4̆éö\ÏK–8Ë$T,ãÉÉI+u'd ¤T†4'“×Dès}N0&5L˜Ã^°G6I‘ýƒýIÓgû{œ5Ä@'ÏK§ ÃìÞÕ{k7¦Íï$˜‘îp¶21Ù üúWÄdii©±ÞÂã BEM„‡•8—€šþÖOú@Ûbs%óT°mzôé 1æ„ðUµ¹bò³d  1«lØôÛ\ÊJFúÀ™0÷žqé“ÏKî³µµÕ6çn·[u~~ÞÆ5õ»*ؘ«Ö“¹$iÀø/>ùɪªúñ~°n¿»n=zÔµ#rÐéÜ%Ï÷ûý‘„l öÚZév»í$Týü蛓““úú×¾V?ñc?VUw:z€{jjªVVVÚgµ©Ûí¶¨ÑÒÒRp)¿9<<¬ùùùVÊ3I…­­­']éÒªªG5–(e:ŠæµùßéÜPgþÎÍÍÕöövu:&§`Õ¹g'Ù8¬º>ãØe$ÕgÝýýýêv»õ}ß÷}-ÊÕï÷G$UÖ™õ¯Oå>HÚ͵ä]///kuuµÉ9Øe¶ÉZMGÈ{’ãèQ€éééZ__‰ä‰ÅÖ‘±™˜˜¨õõõ&[#»ÉÊ3*KÉ]˜˜˜hL;g@›H^8'ö?Ò¥^¯×úww·íUÕ¤/jݧ3¡Ýú][­yc‰L±5ƒ:ÆwOÕMpÍöbàÍ»N§S½^¯í;ÎBð ûœuž6ëèè¨I ýκáLkãýõâ^÷`þ%¸0gUC°6==ÝÂr@O°‚%N½a&ÂÒ)Úœ²´  6«XYä1ºÔWUÓHb‘°õ˜â¬.LI²‘BÕðDÕ-ò@‰‰‰¦ M™F§Óiarí?>>n`7lÏ· bèS× ü1ð´Dü«î;ƒ,wÈYÉŠÙ·JIr@l0#̰p>à=ZÆ*æÿ³N» sdì±r9€Ë†,Síf dbb¢±ýƨ‰Q‚Ï\“ðeã27³4§MÛØÞÞÞŽ”•úR®Ò¤tóÕíÞš6??ß@€5%QMŸIÌ”XmÜ›ÞÚûdušn·ÛòjÖÖÖšS²¿¿_>lÏÝÚÚj ¾×ëµè —ì¸ue¯ªæ\^^Ö×¾þõúÐOüDÍwš“´í'''µ¹¹ÙœbrQë>× ¾Ÿíïï7GÕ³®€Kö'ÙI•cë÷~÷wë'ßûÞúÚW¿Úæ&Ç–ýp!*0ÉÓÓÓõôéÓPjii©­a@H÷=ò$šë $AŒ½?ÖŸÝ¢ðàA«¿.Òi=æ²^8ŽÎ-°N°¸"g333õ®w½«9kˆ˜ÿôŸþS“¸ää˜a©ÏÏÏë;ßùNMOßÕuÇ {/Ï$ç`ÃíKKK-ÒÃY7–æÒ‡ƒ:M´0á§­­­zíµ×Z|ÎwJ•²Ä±œ}ÏÖŒK“8J‡ ÛnŠfZWO³1bqq±ëÿðÛ~É)žœœ¬ÕÕÕêt:µ··×Æ‚­äðrlVWWkff¦EWµ“ì¬ßï·¹¬OíUIâÜ_/Þu¯™I®Ô.M6Ð #úç²ÙÐ['Û^5,O–:áü“ŸÇŸ¡M²ñ]Y&m\‡¬ÝãmQÚmü¢mÍwÍ{ä1䩉´$Ë›ÒüŽûÚ¼S¦”,MFDò~y1ØØ0̶Í2™ðì— Åãl{^YæL^çf»'''GªjT ¨ûøYjˆó^9'|&Ÿi“”–ý•}âU˱e›óûîaŒÌ%$ãàû³³³M’!Q­êL½Ó¼ò|c“•n2€ƒ8Þ'ÆÒûx?÷Ö?æ‡o¼Üiö‘¹1ÞæöVUòÖeJ"²oS«m9Gü_?¸Ç`09 Wö5íUÞóó¿ù›õcï{Ò P H}ëþÙWæÆììl­­­5ðšÄ€1Ô׿‰yŸó"ב{›«ÞUrçÉÉɈ3äßÉô7²Â÷<ãúúºEú²Ÿjmm­NNNjww·öööÚš™™ie å>d%÷ÉBÆÃ¿Õ8ÏñÿœãcšW¾—Š2æ™õ뫪•ù´†µ1û>£1¾—•ž´9Ûë5Ûë×=]"6©ç_^^nDÌøgÝW¿¥4_ÖÖÖÚóÜßç̹¼F>íiföQ¶åþz1¯É7Þxã¿õÖ[õ?ðÿ½Ûrý7º>ù]lžöIê:Ö4tç°´™,‰XZZj,fȆdsÃbT uÝBâØ †áϰ'#›,§ŸIðó92’,Ã)¼ë}ªª½‡ö{7Àãæý1LX9lšM`ii©R?—,8Z0Uɲc¢I,HsÒɯނ9ö>Ø9úS`4+°TÕˆ^SøU;Ü_ûEZ²ÌœE껫ªUGI°Ôb™Ìy^j|E6„ÊU̾y†‘3Þr"0aYR[œUPÒÙÓ¯ú9ËebïÍ’3÷ÍÊYžÓ\ÅìŒ]&¿býZ_¬6­rÕ0¯E¥ì›wËöŒdòfggkww·ió¿þÛ¿]ïû‘фө§cž²³<§‚üîææ¦•…L ¿1õ9ó@$ NHÛ$tbÄÉ¡þàoüúÀ?Xÿ×ýPmmmµ2¯o¿ýv“`ûÝcoo¯U39??o‚8•)G#m`sÈ É6Dñ$qk3¶ÞaQU£5ðÙ®LŽ”£„eÞ.//ëÛßþv-..6;d=cÀS—m “ø¥ìîî¶öª&dcv3Œiƶc´Û€Ýn·å‰²½ëëëÚÛÛkì7†YŸÙ{؉‰‰‰f‡Í«^¯×¢8ÖÈùù݉ÇìÁÊÊJ+AœäP>GD!K$Kqœ~vvV+++-¡6í¹9l|sž°1l¤yqãŽ\ IDAT!¹W¿*s›{–œÉý¢,ÓÓÓµ³³S#u÷ׯ´ýU•³!'ëðÿ8˜pý|}ã߸—Ù¼  $d¨h­ÕË3Š \þLH2õ´™W5LÅì?$=ô•>›õ¿Ç/ aJvƒ$‡A´ ¤^XÆ÷F6H «j¨iµñú.æ÷À9¶h° S w,#)Ìî°mäQ¿~LV)µìÇÇÇ­³>J¶A&¸µ9Ôî=77×õö’!Ú’Æ€ ªj¡÷Á`Ðôá)©âœi_V¡ðN€‘ ^äC?®9‡|ÖnÎqt8PÀÌg8ÖÊÅÅE“ÔØ@É8|I§ Ûí¶jÖÅþþ~Ógw»ÝVª”nÛ»HäÕL3ÆÜåðp(Õ±Õ’ï¤ÐOûÎúúzÝÜÜÔ¿ô¥ªªª«ªiq­ÑÓÓÓ&Á«ª6NGGGíXy ˆ³Á‰ȽÇ“è^JZ€öììlKFääZÞõƒ?þãõüÛ{w"íw%œèÃÃÃæäÉa îêã±tÇéd[KtêœGr/ìuV›!cŸÈ5œDšÎ{\ªè3~ÕÍÍM­¯¯7"†|$¥d€¦yÎÑS×¼ªˆ¤ùúôis09\àååe³û¢‹ Zóqs±;æÌÊÊJ»¿¹‘R&kœƒ²ººÚ˜n§ñžÕ£GÚó¾$uòFž€ÁÁh¥%#U×òwBû’媆µÛ«†%-…WmâB懲Ñp^fgg›œ@2'¦jXK=7¾ §g@KÄÉÁZ©¾Qƒ¬êPV:kXz?Ë 0Á4¦Œ´"Ãöú”´*µãéØÙ„̓”ne›ãa^e’%@–Q#À sfìÌZjN‹¾Ó/Þ#DŸYKÅÛÛÛv§d¿T€f2ëÒ« eîžžžŽü ËätѰ¬QoíI°æ8Úúë«_ûZýð{ßÛœà ÇzrIô0«æ`Š ÕŸž{yyÙJOfµ«¹¹¹v°”±êÌ'lcÊ|0éä$¿ýõ¯×{ø‡“mÜ1Ï4ÌÚã ³Œ8¶ Óž²[Ïí÷ûÕï÷[¿w»Ý&¹cÇŒQ:å"ÏñóÔ€sˆ­ßñ3¤FJè¬ëŠOùÒ«««6§Øz|UÒvw»ÝfßÌ,º¸¸8rf` Ü;È)%2ö€–ý6Ó©>_p||ÜÆP×>I²ž'’–%€Ù]ÎZ柄Z×d-Ƙû™ñÅK§;¥a"1Æfnn®IÀØ"UÑìÖsJOUÇR±‰ÄFÎÏÏ·ÃÊ<' ŸwŠzß_/Îu?º/ÁÅh`3a‹œ………Úßßol¹j î“ ;}çÙÙY­®®ŽH0Æå0ãI‹BÐ.LC•HfÝÆ&Ô ¼ÿ4òŒÞÌÌLõûýšŸŸo,x‚àûôô´UÁè¡3Ö 1æS­}=£ë½³·ûÚtSœïjl„ÊGØ¥ª;¶óððð{¢ Õï÷kvv¶7íNíªûQú^[1bþaÃÒV åBtšûûû-:ÓétZýw@ÞF ðç<ÈFH<â’Øè«‹‹‹ÚÝÝ© 0îîî¶ UÕÀvΘ®®®64¥ ˜Á¬êcí«¾—৪;999Ù4Åú5Ë‹nnnÖÑÑQ“’$3 4éÏŒ~õ4 ìcºßóóóZ[[)¹èAà,aÀÍÇ,ŸšLTÀÚ¶>9EØæd%=ý ª0 ÚX±$.€-ÉÁÙÙYõz½’Ò14Ÿ‰g.//×ÑÑQ«'ΎБGë@tR Åþ.//7I Zο™™™ÚÛÛ«ÕÕÕæTØûØä|¾5Îy³îÔϲžHëÀ÷Sv¹¸¸Øœ`¿Oöÿøø¸–––Z!˜2ÞZaGôF!DQ?~Ü"l"‹I\Ý_/æuŸû\ŸøÄ'FtÌ =yF,Yr Æ¦„¹Ê=ØN¶6µëÚ$QµêΠIÌäµd?°$@QÕPºb“g¶/..Úfç;ØH›-ÿÕÕÕˆÓƒÅaØ3i³«þ¶g%cîúpÆD}ÿ÷K†õ³ìÃtŒO2Ä6>›X2éɸ&#MÛ›lÐÍÍMÓãr†Œ­þ̈ ókbb¢i{Sëj|mBWWWMÒ¢ï[óÛ©¯l€æ% {|ƒÙ3Ws®™?Ê£rÖlÊSSw™G™ mÎGIhƒÁ %!WUs*õ¹¹ªï0ÉÖuC‹ÍáiЧ’¤3y¯êÎ1þÚ׿^?ö£?:2w8@ '¢Óé4}º9çOpÀ«†ò1¬x~F¿e´‡S¾°°Ð’I\ô‡wI‡#£@GGGõþàÖOþÔOÕ7è‡šÔ Âæ“8ÐÌx›ìc–ÎÆS{Œå×4Öl‰S–6d•.¼½½m`Ð|¥ìõz#ÑËååå6'ŒeJ‚¬6ø¼¸¸¨ííí‘ôHôffîêÐ{gëÆçÌ+ÒKާÂ|Ï(Š,äòò²9-ý~|#S2ï /?¢ßïׯÆF[§J)³[ÀrÊר0ïÈÆf‚2üæÄ³?RÈ|å(‹&Nèééi{7v„5Og ÷029óree¥öööZ)\ö$ 3ÎóÂÂB›óäØ~t¿ß¯éééúKé/ý…÷×ÿ¯o|ã÷2›—ágo«ª…7ý>õäYú+/ö(gäòþ´‡©Õôw{L¦Ò|¾#<œ¬­{`¬²,â;µ×&¬¯û¥t$ÿö{õÅSfñN¡Ê쯌4äï³´X2•ž™¥óÆûÛ}ÇßOÙ=›«géÏ”‰¸ÆûóëSã‘åòÆß×Ï Û5ÆKÛyÏ|ï”\\\Œz§ñð,Ÿ5Þ©_öSÎSk%Çœ#“mŸËÉŒ¿Ó¼$5£ý·ž}7/m0vÞ»§­ž—ŸÍ÷KÉCêuÙ »ãeúÈ,¬A÷/»8ÞcÇve?y'÷tÙÙÙ–xì÷Y†4KzúÙøºŸ§Ö@&ÇfÙXk?KޝCëW[ääûçû嘼S BL|ÊHÜÿßi\²ŠÖ`0h¬;‰L¾¿÷6‡ÎÏÏG¤~çz§wN»”ëÙø¤¤Ä¸Z‡ò¼0Ùù>æ’Zî9žîc^åú×ÇiWÓž˜¹ƒ¶¸RŠ—ën|M¹¯w¶>ÆçùïÞã¶I?ø¾¹½¸×½Ìæ%¸ºÝaÒ rg´w’{F…Æ<åØL¶wrrxj'FËÑÅŽòU£›ŠMÕ‰‘X¸ªjlRÕÐÐUU«‚IÍt·;¬¶#y €Ë )Ág"u¡UC‰ f“®õ3›76ƒä3ÂÄB¤6!Q}!_lª0>÷öÛo·va¨|ÞÑûÛ0±¤¾‡ÇØa²“­Ì$Mý,IÓ•eîHy°z˜f ‘Í[¦n»yd®‰òÐÈW 1 §¹àÿ¹‘éï2 š Hâ"II†ÄÍÁ¬ZƒUÎP>–kl¼H°–¹±·N§ÍGrÌëÄÄD›ßƒÁ0©ÙýD”ÆÀ¨’¦X÷{{{ÍiI­8Fþúúîà+‘‘Zd‘l»j:é4ФØédONNÚØ‘p1Ym)פïa¥E8 ´Uä@sƒKËž2ŽLhL‰›(WÛõÙññq½ýöÛÙfÃTÂÎ'`4þ®ÕMÈq¬ëåèè¨É¸Èžnnnš<Ðú›­ÃÃÃæÛJ çÝž?Þ;øEÉDõ )ÍôôÝÁ_"_l°y H³Á;;;Í®XÞå­·ÞjëÆ¸³¥ìØááa‹% Ã~MMMÕññqû¾ïJj ­„¤=D’éùùy‹¸q(Ì‹¬Òµ¾¾Þ¤ì¶h§§§ëÁƒ#Î[`Ž™[ìSÊÍSýíûì=;šÅ8 ãÒ$²W øœË”FÝ_/Þu/³y ®_ú¥_IºªªV?;8V óoFÛ&IF!DLOžõ²«†§2d6–L"̤*zÓ”ÌÏÏ×âââÈ&Nâ‘·мwªº†NÞLYÐ`0hòŠ”9VT ™ÀÔ®ÚD„?SIg¨@ˆ“³=ã’›´{iG²2ƒÁ]IÁ¬~0pjtl‘g ïgmgrŒ'Â;ŸÌ- ±gìI€cu±ݸMÚóPÉÂÆ(¥<>ÏÌ>«ª9"ÀTnZ´³SSS­úgÔ<^ZZjsøµÉçÅ™å§~9e3Êú‘žéásîÙÙY-//$ÒåüP;_¿Àfæ ø='˜#ìýµq~~¾~óóŸ¯ÿå¯ÿõ:<ãêêªÕ¦7‡9ɶI”ÌMÏþÞß߯………–{ _å£pª†U¡È7Rºæ~ÍÇÉÉÉ;óûí¯Õû?ðúæ_ù+ß#3Ë<”’LMM5àeµƒ½²®ü?%^úƒÍéP&“¡Í’Náüü|« ”ã°«æ ij îO’2??ßÊ˲õìp§Óiuù«ª9^æÈÕÕUÓÇgµ*ÒïdÍ;€VN‰ü„”Üa·§§§«ßï·~Ó7ÚiÎTU“‘âØ2áVr+[æ}2/Ç:MLj¨ggïê½ËÍÈ%ò‹³$ ˜411ÑÎ ³"Ë&kTnÎüü|+OJo̲šŽÜ‹”ÚW8mi?Øëè¾Îü‹yÝ×™I®¬=;;;RõÁ&ÉKì”ìÄ(ÞÜÜÔþþ~=xð BOUµRzãÉJ­vØÔl Y `048ewŒ£­týªái´jUCIÇææfc‘Ýo©e¨S“ X©™Ö‘ª!ØÍwgÌm XæLÄMÀßív[eQ›ƒdSºM+Á’PoÕ0©UÂÈ*6FàÅf‚ *€óÂæ©¬ž1Á~eâ¢6ëSí×¶&ó ÌkëÌÌL+cH—:ž7Àñó,=Êi1~œR èùùyõz½½òƒêøø¸‹ò¢œŠ~¿?r²fFc¶¶¶΃j¬ó ¡}ç š;XËííív ÑæææˆÖ—žÙ||ßI:b¾YkæpÕP&Us84@éÒÒRcsÍ1I”'''#5Çeå–¤’•^܃Mʃ²8ý~¿=7×2Güôô´Ù)ï6;;[{{{ Iä¯&9ËÕ°>Í{k 0W×{vv¶Õ_WzÈív»õøñãönÖ²~8??¯ùùù:==m OND²»€¯hQVüªªæ îîîÖÅÅEsd1›f=ZÙObÜÙ(Àß|???o ·æ¾~ÓÖÌ›pe>K¯×kö ONÕNó.™ëŒv¨ì’ù\*ÏdÄ Û‘6È3¼ãìììHÞˆñá¸é}¤ÍƒÁ •õ\¹Ýî°0BÕÝ>hßpoó$«˜¥”IÂïÅÅEsìô;BÍûˆb_}5.Ý»¿^¬ë^3ÿ’\777#Œ¬p%cêwɶÇV õÂX[›±²6cÆ3JÕ`»ŸûW Ù:Œ£¤¶50Ç2²ªŽÈ|²”Ÿ¶xw?#çýðË“9ÕïvɱÉÚrUÕÀ¯Po†¹} M ?DRwY5<uœñ[\\l‘0Ÿ}î»À¶ªKïg\Ðe›8ÓÓw¥ÿÔ|ÎÄV,QVGñ'û81_æ6Îæé}$ýaU•¡—Je"-vÝæ|׿ÛL=88‰xˆøöóøø¸%tê ï‹5%5È0j)7²y§vš´ÅÚà“Åq@ü õîUÕæXkÿW%'e!«¹ ÄaU5§ó%úµ´´ôŽŽ[C:ÔëõÚ˜Y§Øà´9Öw&3’E4ægÊ{Ì)ýª¯9«êûsxÈDÆIR‡ÛÛÛF(¸çG?“‡œ}’,ëS”Â:Ñ?d4ŠèÇ\cþ}á°&•¬ôE‚ÅŽ$©“¹=i_z½ÞY‘àh5·°Ò@©w5¯Øx²§ÛÛÛê÷ûmþì¢0P64#"Ö«¾óÿ,}œ¶¦jX‰Kxîx‘ó‘µîœž`™3*ÿKÔ%#$Á<>>n'ò¦ƒ‘‰Íl^§s—@lîç:°§J6ÿì]÷ºùûºgæ_‚kjjjdÃd¬ƒA «3 GGG#'NMMµPh‚LÆ.¨RNß—Æ …fÙ‘L Àë;ãåíT€ $ —n˜ª”dâ™vÛÑ”ÃÐz ñV “j1=úøÚÛÛ«ÉÉÉV6Òw1^YxËúçÀ1@¬nq²ÈÞ€M§Éߘe® 8¿_5Ô§&ëk“ãðŒu¾7¶Ý&¨ò…ù Ÿ¦¦¦jii©vww[;µmmm­¦¦îªªÆzgdB°jú hÊMµÛí6Ѓõ4–UÕØbsÎïð–U.}{yy9¢÷Æì ‰¬úquuµÉkT2‡Ççf–<Ô^Ž € ð¥¼j¿}GˆKi³×Ç+++M¾” ¥ñµ–EÍTýPŃ,ãâ⢽³Ÿ'ý)j„¡œššªíííšžžn‡Åi³jN§ž?^'''õèÑ£fc[É9Q ?#ævJèhÒ”cdÏUUkkk#½™™™ÖŸÞïôô´I#8òl;G.!"$wàä qT÷÷÷Ûi µ½½=Âz'@Ö~‡5±·óo¿Íc\λåååVCÿææ¦E"¼ëÙÙY;íWN…ÃÐÌOrÄííí‘|‘$\fgg«×ëÕóçÏ«jh7———kggg„TÑ–n·Û"Xîå¬'4§ŽÝ8Ê1!¯ñ;cx~~^;;;MÒI‚˜•õõõfëŒaž­À6ÏÎÎÖ£Gêââ¢9þd l•wµS6RT”$(s¿Œ—}uuuu„<_»™Ï$‹Ë½úþzñ®{0ÿ\X›i€Q5¬òx+6 ›UVÈH¶,ÿ؊ԙ ñ¥Õï°XØí¬_5- ¦ÒFˆI³9îm£ MfQu·‰ÔÜÜ\c„¯|ç”Ñd•‡LÊšêSÏÀÊÉUÕdLã%/ýŽpssWçŸs‘2‡ÌWpa{’MŸnàÛ3io“4¾’6õ#–O¨`Æ~ª.ɨ¿õ“(‰(A2_˜jlŸì6SN†wQ.¤~ÎC›œ.™‘@Ð:Àæ˜b¤1¡úSzyyY-ìÍ 4Œ+ಾ¾ÞúÄJ‚h«†Õ<ÔÁ·a›÷ÙwJ†NLL4° ð’pÜÞÞÖÿþ¯þUýÏù/×êwÁU5½®¤À•••¶V%žbZÑ‚œ³Ïž=«Gµ¾³¯¯¯[/..66÷èè¨VWW› SN³]U­üßãÇkkkkd,3rf>ý›ý¯ëCõ¯ÖïþËÙ¢©Æà“/u:&ͼÓ."%´O­rëM"·ê83p)zÁfdIURœL•¤oŽžž6ÇLÿc¸ûý~­¯¯W¿ß)kjž³Í"†ÆÄÏwvv8ÌÄLeH9À×××µ²²Òl60 ZMsë„ÝŠÓiýõ×ëû¾ïûjee¥vwwëÛßþv½ùæ›Í–t:&gÌ}‰ÌÂ’¶¯®®ÚéãÚlcS¬_óPy[ïë Ä–g,..¶µcO SåpÐj²oéK‰Éʘ:û¡jXÈÁz1¾d2;;;mO`_’Þ3ŸEôÏÞÀÜ_/îuæ_‚‹1¾Î„7W·ÛmÝ,//7Ã\»€dÿN)IV½¨cJTDàúúº0 ÓKƒ™¹jJ“±Èä»õõõÆ^b7SÃ[ugðONNÚ¦Cj¨2`N§ÉMý eÅ”|®öVÕ[‚ö{ðo<°ô¹ñh†(™\ÀŸãÓï÷GÆ®ªšæ˜nˆ°Y`³L_J8NNN›ŽNþ_¥SfSõqÕ0"¡ÿŒ'pÅ¡Èþå(ÐñÓé:Ê»–›q¯×«“““¦V±C~†ñàÔ¥Ä,û‘ŽVÅ¡ï Ñg.-¹1KO>Ãeþ‹¬p’ºWÎÂÜÜ\íííÕÑÑQõz½$'''›N[»«ªÕ¡æTº¯>/Ï—µÉEMR· HÑþ“°)›››mˆ¬…˜ik*óäÅø)™¹ººjN„˜ªáam"Æ›^T#ŠUwØÎÌÌ]öÍÍÍzúôiíììÔÑÑQ³SÕÆÆFn;;;ÕëõÚ\,E~ÈźÝîH„Q;0½)ùÂü®­­µ¤ 7‹‹‹-Ãþ‘ø¬?µ÷ît:­ápÖGfoo¯–——koo¯fgg[´Nr¦¹ÄỸ¸h‡ q¦gffêOÿé?]=ªùùùzøða½ç=ïicŠa“vww!`®c Eɬ}yOæh›ž¹Cö.m3¿———Û<~öìYûŒwµ>ì[Æi}}½9ö•Œr'•¢þèþ¨ÎÏÏk}}½Ùoç èCÕw¬åÍÍͶövvvÚže84ËšX[[‘,Y[Öÿýõb^÷`þ%¸,z›:V…¶ò9Ì®šÑ)s©†F±UCð›l< Âp2BÚ”I}ÂÂÚi“«&ï/æ{9ÕÒw’YמÓ{v»ÝVÊPlœÚ—ïx¤Ì$Ûæþ.zo?ϾÀa¡0_€K^îIÛž@\Kïç)ѱjwJqü.ïÐfùH!ûqmhFh’½N™ÚÆC"¡ý^Þߥÿl•ÙϪ†åVÝoï9>/s›#Ö4GR?ŒGžÇížûd”:÷@QL6>+¸™ ˆs5s“H•ò=íÉ$…ö«œS쑵©ioï¯ûºó/Á•²á6É9)§ašáÎNaE@ûy~~Þ¤~'³ŸñÂ*Kêa€“i©ª‘zÐ6ìQ†À1v$$*ŒxfU0¥ ¾’vãò ŸÃ’N–6—”9`Am˜òd^%”Hú¸ ¡µ ÿ7{ï$i~•ù=y¯ÊÊKeÖ¥kjzzz$°$ÃbÄEËÍ^‹@Hè2H£Œ.¬Ã¶¼Žp˜ý»k†ð‰‹%Bò @„$li%¯ðn­-/L‹Á‹Œ.ÓÓÓ—êªÊkeeUÞý!ûwòys>lìÒoDGwWe¾ïÿý_Îÿ9ÏyÎùǽ`=ÂÂó„…¶s±i³é3V¼`Š)·I5úGR„ðéo ¬›ïCßxb¯W‡ñÒw€"gÈ}ÜI€0¤bÈ ˆ*˜7ÌoîņçýŒ¦5›ÍÆÂì’ì¼¾¾®F£m`JJI€/÷Z[[Óõë×%I—/_ŽÓ é{’¶;„ë9ˆ Fd©R³z½”°FQ IDAT÷œL&!?ðò€Ë,¦÷ý˜ÏÏë|‡Ãȹ¡/˜“ÈÑ`i‘Í‘à—ÍfÕl6ÜzYÒ›7oƒ‹¤ Y U>|\`Dqš˜‡€¿šÍ¦²Ù¬êõz"ñ}}]ÛÛÛ1Æ©T*ú€]©T‚ñ'A•{À {Õ'À].—K”D:â2#Ødú›Ó“±;Œsµ×ë©^¯‡½¤BJ>ŸE6› P ›Œõ¢ý~_·nÝR.—ÓÃ?¬n·ìw:=¯%Oµ¢’0ûì#’"Ê„-J§Ó‘M”d<«Ûí†#Jr>ó ÛvëÖ­Xç·oßÖîî®ÆãqÈúp4ƒAèà!X°;¬ú('Ò5þM IÈ춃æŒ|«ÕŠè™ˆ$`<×ÈK€b÷¨BS(‚ý§\.mçóØH¤{’‚øaÿÀ‘Ð{œ;©¬AžåäÖêºû®˜¿.6_˜IÁœ¼¤$›±——ĸcø é’ˆ¸@èÇH² S–ËÙkÛ°(^®F–g±© 0òrŒ$qÑ 7,!÷q)´`§Ñµâ>ý^’¢Î=‰sl\á±`cøéw¿’¢ÔŸ—µä½é;.—$¡}öDQ€á|ÚH§î¹ƒJúìýéU-^ÚŽÍJZTea쨶ÃÇæƒS…Η9ã.ñžlj<ÇÔuö€q6D.w˜hó’ïœÕBÏM¸¹ øf|F°hÝn7¢&´ LÄ…wšL&!ŨÕj!ÙbLp†ø>ýuzzªããc]¾|Y…B!±C´¾Ò\‡Îø§ÓéphxärN'Έ°")"ÿPMû2™LhêýÀÀ;r0Ð$ý` ïïï“OÅ#@²Ë"hõâ¥E¢,É®€cH×€ãä8;??×õë×µ±±¡›7o†~Ùû°Û톒98ެEì KÉ ÓêIÙhUyWÚIÅ8R./?é%Y ųùs0š¤`ßHl0Þív;Àöt:O<„™ï÷ûÚÜÜ 0ä óÒ¥KºqãFÌkÊåá@Â$°…1Ìd2Á–"‰qÙ•Ÿ³À@¯Î<Àz+ØTúÒeô;Öý~?!ÓÁ®ÐnÀÚwÚÀ…£Áz ¼bv‚Äyœ—ëžYK´™¹Cr,=óÅmÏ¢ýD`ø7ãÏœd^1oˆ²Áäv:D•'l36—¹Œýt<§HÇi¥8ËÌ@66À%Ì;úÿèè(ò;èÖ¦Û9OTf.Ê!`ÙÑã3WqÚ°­Ì/—™²î±9äßô;íò= Ñ:Wæª8)…£Ñï÷CâC4»–J¥´µµãI¿9ÂÆ"+%ǧ›Äeœ¬T*‘Õu÷^+0\V´¡Î–:°#ëÃE8ØM*<`ø`Eúg¡`Ç`”ýÜ‹p),¿or„ ãŠäý¼š‹ëLÝ€{ÂY=—É`¨…ÎyýzÚ$-Ê@rñ;o¬ à ‡ Ñžï‡}Áøpb*À‘¾“›M¹\§ÁA,`šÏy™JÁDhÆÖ“ËØ`ˆ¿°ÈÌ×Àv:DÉO.úÊõÇÔi–¬¯ç7°1Ów0€C¿{rŸË‹s¢1ÈT˜/lö×?»ŽYL>Ÿänæ'k ÖÝA½¯Igô=*Eù@¶­­­LÕj5$¹\.ä%„}³v=›ÏÇcíîîp÷ igg'$~œœ$äEår9dEòþr@B{[­–Õëõ"’@N&쨓Ì壣£˜kÅbQ7nÜP±XT­VK$H2–° ÈŽŽŽbýö‘E8£œÏçU«ÕBúÓív•NÏk´çóùXËôG“Hd­×ë qŸápò*?xw Ue2Õjµ8ùuwwW­VKO?ý´2™ŒÊår<gÇ„{a'ˆâ”Ëe•ËeµÛí8ÈŠ5Àú¦<ó†öJ‹Dnê©·Ûm¨Óé„þ½ÛíFß #ÞE;kµš^ò’—¨ÑhèñÇÛ·¶¶rIš™³ô‰Gçp€°µ.³¡ cÝívÕh4Ôjµ¢^üúúºbÎP•½­V«…³Í|„\`ް°—¾>Ü1Å©â>ì7D#¤…Fîƒ]ð²Í+™ÍÝ}­Àü=rÁª„%%X @¬l.—S©TÒééiå.-°œ½tÃé ¥l26M +¬Ÿq ÚTÚ.%kW/Ëh8$`Ž“âŒ à>“É„n™öæóyµZ­Dýe6·F£lŽ´>Ljšª]ºØÇÁ#Ü P «Å{ù€ñd3U"œí¬Øt:/‰ÆF“L{¯,³äl0ÔÁ–¡v˜*.ò+œ¹ÐS·™ñ`|™ÌZ­VB¦ÂF*)Ù¼è;6w/ÅæõÀýFgÂÉ“ Òƒ ƒÍæ—÷vùŠV gûU¢†5ó…è l2e‹ÅbBÒÆØÐvgë<Ñ{óæMU«ÕÍK‹S—Ç"1Ãawˆ$S»ÿüü\‡‡‡Ñf摟FͺDbäIðìDyÜYX]wßµÝ{à‚IâòDA@‘×å†ýñrq€dŒB«Õ Ãë ?l*5ÏvÝ5,±ƒ8רûïØPaÀ8±–‹Í‚äSjk£y¦]ËRÚ ¨À b$…C:ãïàR³&`rh‡´,ð~h~K€@4mbl «»“ET‚90–«W?a<8ü°É³ ´Ýu³Åb1q@€s¸\!g9²Äå’—1 ƒ`ÉÑââ°ˆJÁœól«´È]ðyË=‚y¯T*”CÀW6;O<|#O“æ@´ßïkkk+À-€Í/Àޝ¥““íííÅÜ®Õjáü¶Z­`ÈýîË|À‘•¤F£¡lvžN’-ãÌ:dò<—æðþèµ=І¤ùº÷ÙlŽ6åôôT/^ÔöövÔMgýS>é!s“ué‡Áú£«'úk/)¤mÌ7À¿G!9Z­–Æã±î»ï>ªP(„ö{oo/Š HóèH³ÙÔx<]<6›õ‡ô&ž¾¤=ê‚}Bö‚´‡¨€z:jgg'œo@:ÑöÆYà Ì;Sá¡P(èOÿôOcî‘/ƒ½uÙSµZ ­>™ÄþÅÚ¦ÏÉ_bŸyà$I7nÜÐÖÖVÂñæ< —Ópa$E°ËZ!`ÏýLìQu"].\H83årYjµZ‘O€e81±ºîÞk5º÷àå›>,¤0ll¨Ë`†Ëk”ÔJ ÉÿÆŒßó6î{„!ã‚=õgÓ6>CJÛ³Ùl”Nó{ñ=ÀŸ÷Ϲþ’çSUÙ?ÿ®ÏK–-Žv-—Ìó± J³y¦‰ÿA79 "Á±ôúÝŒÍò3åü¡ ?¼ûæ²ÜŒ¥u/uȽù>ì9€Ä£>Ìåþy¶ñô±ù3VÜ—>§½Œ)íX–øøÅ»,·g‚1b>Ó/ÏÖ¯’‚Aó{Ògþå6à4,ÏååþeÞyùIúŠwñŠ/€,Wú„èýäã±<î9úÅK:(g~ú{?Sè‘©R©ó¸|/ÆÆß÷ƒ‰¥ÿ›ÍfHwøÿéé©:Ž:Nœ8ëëÆÛE¿ø¼Z7æÂééiœšëѤg³ôž_n –tú’¹åkß×;—÷ï³lCý¾ÞÏþÎ~&…¿ÏS¢8CüÞûÁm"í!'ÁŸíò¾Çwˆ´Žy6ý N˜ƒþž~°’·Ï×.cËX,KcÜFrñþ|—5Æ;s_¿´™Cø°Í—.]JìmÞÎeAÛÿ¢µ¶ºî®+óÎw¾ó§®]»¦¿øÅÿ¶Û²ºþ ]ï~÷»%)Øf—À""@¯K{ÃÍ=`\—'ròH\8Yv9ñƤËk0Æž¤äL-ayf!dkí§Òæóù8M“&Ʃҡ¢ŸFêa\OFÅÀÓ'È@¨¶ƒVž4¬>õï©(ƒCe e+,6 ,É¡°L¾yRû ¦Ÿð9ãO@¾¶¶–HÊ$q{Òo¼»3ì°CÎ ÁLÑfær˜(.­Ü“¹ì‰•µZM{{{úÞïý^½üå/×åË—uëÖ-u»Ý˜c®o÷H…· yÆ–µQ(BGìíO¥Rq¨íƒÅ=;;Óææ¦*•J"æZr$cÎú¹<Í|>Ÿ×öövô«”ÔÙ3N°¡D"°}ìE/Òo~ô£úðsŸ«­­­õÌGÖŒŸªê‡±Èdå±D8¨&„ð{eà Öܾ};æ.Q<*Ëd2™Dýw¢y”>tÝÿOüäOêg~ú§#¢@dëääDý~?ls‰X*•ŠÒ8È‘7©U¬ˆ´ ƒ¨™Î¼dnxé¯Z­R¤&¼:yìa>ŸOTr˜Éd´³³£F£ã†ôe<žç=œÃ]­V#ŠV]ZäƒÐv$+¬Q¯Î5#ò…÷¦Ðo€mžÓn·#:›Íf#oÀO/f=-ç­¥^²’Äïn·eZ!N˜o$ìI!/ÃOâÎfI÷^v¶;M”š5G›¼,/v—qb IÆF`ó|=3çý°¹r¹¬jµªx@ÝnWÝn7l mg-q_d|>à~@«ëî»®\¹²’ÙÜ ÉDÒ‚ùØÞÞŽM›M=5ŸÃ{²—3LÒH¸Føý%@…‰¤*—ëH‹d5—¸lƒŠ ^öp2™DÒ2 jj¨aIxÙ9·oh„‘é+ä:0fþž876FšÏ° ãHÁ K‹C¦òÈ7£í—/_Ö< ·½ímª×ë:88Е+Wttt”H$óét^g¾Óé¨Ã e H0Ëçó`ðØ” lä„»yä>ƒÁ ¾G»÷ööB º¡?sæŽI|F£Hªecûý~È@œaßÛÛ‹dbÖ'^èƆv^HðžÍf:88ˆ¹óüç?_­V+¤CÈïh;‰|H[Æã…žžúïN'‘\ΜgÎz’,ò·t:­k×®E¤¡ÝnGb"ãLn¾ßív#1`Ýï÷µ½½­ããc©Ýn롇Šƒé/?o'&\6»8 Ž„DÚʼn«N'æ¦4—É ùÛØØP£ÑHÈÚJ¥’jµššÍ¦.æ&Ï…ø ‡§yooOF#æE»ÝÛLéN·Ã8 Øê~¿Ÿ“ÇÇÇáÔlnnÆØÀ²KФüjµ•¿Œ 'c}"-÷*kì+üNšË[J¥RäG°†‰ P- ‡ðKî6𒣬©lvQ-k}}]Ýn7ò5< ;O”†3ØÈÀ¡pö‡B„ˆ’'¤5 ýñÿqBOΞ<%" Ë%=aóW×Ý{­Àü=raXa<ÐJ yŽÏ‘ ‡Ñá;è´—Ãÿ° 0 2X²øó^‹×õÒH²Ù…V– p{˜J¥‚-E'ì†pÂ3¤ðÌt:Ì ¤'Ö98à€Ø!¯¢!)"hª@©–áGiQåæ“vôÂ4’ôçaY6 ¯ã}%-¯b“÷ï1–ž@L¤ æIc°ôΤÞ_¼¯'zqlZ­Ö34ß8ll¨Ì+Øjo€U¯×Ó`0Ðññ±ƒnÞ¼I¤$Ö„‰ºÐœyã(w@< &ÖЇlšîÔ¹"r³¶¶Œ,ßcm‘è3È@?Œ3=ƒ%§¿ÑÜz¾ÈÉÉIœu°¶¶÷qPÅüåyDÌX_2żáò*#Ùl6Î> "k‡Ü€ã²TkYB@’$•WŽŽŽB"E5ÆöÇç¨ÛíªX,—¤ÃÃÃXO€7¾Óï÷µçg³YDo†Ã¡Z­–z½žÖÖÖT«ÕBêÃz¤ÿqÔÈH2˜£èµÑNãLxn ó…>"b")ž‹]©TÔn·ã°'_3;;;‰ NËÎ6ì=€ç6°ëRò58Éí>Éõ$ƒRc½T*E?@‹Åb8.ëëë‘[ÀóHL?99Q¥R Ûq~~Q "08ðD ]r’N§U¯×ÃYöœßc677ƒ!jÆ^å¬?>‹“н#Y·P(¨ÑhÄÞït:šÍfÚÜÜLdìMØ2H ˆ3NÓÅna3 XpzT«ÕÂ)èõzj4ÁæµÛí•fþ.¿V`þ¸œí€éâgÒBº£Ç&‡l@åɤ°› &áëg;¶„Íc™õeC•6=¤ ÈBym] 6ß]>ˆ…wö„SîÍ;ãHx5ú „$[X./oF6w$|Ãté ›‘—褿¹·zb)€‚¶4¸–ë Ó¾å$-@£Kiü½ ƒÓ6øwé7ÞÿõYÞL<\îRží rOceã<==Õµk×”Ïçõõ¯=QŠq0ÄæO5 æ(ïìsÅœä(x>‡ÜÂ×ïS À‚ ä½ù,Ét8J̤2TÃ@ê¨öuGXÝPžáýðuPK2«Žö2ŸW³ÙŒÒ¸Ø@ll>Ÿy ެÛlL$Pþ\ÆÑ‰N§}éÉãþ‡yáÒ,I±Î!HhóÌÿÍûQR”~€Ñg-`›±ó®É‡ô`nðl’nóù|D[=±Ý÷?_wÈŒX§®æ¹f¬Wˆ)X|l—¿çªÎüÝ}­Àü=p•J¥Ð½N—'§òo¯¡ìL3› €(vC,-†|žM F âŒ(Ñ@ !j àd:襦µ3€'Œ1ZrÞÛ~i¯ƒ'6v*%# +Êxm†%• s:ªÝnkkk+6)4»¹\. ?›Î µÊa{aÂø9@Ô#gð* ŒG·ÛMûÍÆÍ=`ù9L2wþ`îaà]×ËÆHgƒaŒ¨ÀË墥deX0@ á-R™F£¡N§£V«¥Ñh¤f³ÑÛóoöäT^ ”M¿X,&XÝ .$€"²-6WÖeýè'Jó …ˆp@)= (n·Ûºxñbô·—2…=ædVdD2è×ñx¬×½öµúO|BýȨ×ë©ÕjEùYä4žŸáÕXHv¥ê •4HøDöâ¤KÖ2sðìì,¢#8Ê`ޙ،ÍÍÍDžÇúúº~ó£Õ«_õ*Íì§N§£‡zH—/_V³ÙÔÍ›7ã~D<¤E¤‚õ8Nƒí zÎsžùFTAÂA¿º”ˆ"ï¨e>Ôëõp´&“‰vvv¢‚ ‘>tÃ^×ëõìlmmE4ŠùÇAp8>¾VÖ;éÔ¶wé “¤áñx•›X#€yˆ”ÃÃÃXœw€ 'b…SNEûä“àœT*•è_À°¯ár¹•qp\`õÏÏχ‹!yai6›‡!»¢V¿´85))Žû’!iqv ù,O=õTìaÌ7È&r‘èWJN¦ÓéD•+œv"Ì ¢Æ¼/íÞÜÜT¡P™¨ï1«ëî½V`þ¸Ѳ±³qaÛ,|On˜¸TFÀË]²9ãO"ª¤Øp1ÔÎ0°±YÂxybå²ìCš[Ø0iü–«KÀÐ2\úÂß8”FCÖXDªôÇ)yb,}ÓK_`LŸ…Ak °…™ñ>v6‰wõ>ò$bú äÿ§ß€w€/ üüü<±‰ñÜr¹¬^¯—`°a†aéW?Æ0”Íf#ñ×Ï`L`À`UaèSä%Ò¼ºÅ“O>)I öÞeÎ<3·qÈ`ð`Y½ÏqD Œ%I­HTTè|S|PÊçIŠ¹ÍØ¹DFš;èû%…üV`A¿<™÷€j$­V+‘DîýC‰>§½Üë _øB½ä%/Ñ… tõêU}ö³ŸM$ âÜf³Y%¤{È'0–^åƒSH···c^£“ôyE—+¹ŒÃƒ¬åÖ­[%"bäó€Òˆ”òãýÛí¶®_¿®ÝÝÝp¸¦ß#:8ôõz=; ðìl6«Û·o‡ó‚|ŒD{''ñälooø&߃yŽ Efȹ¼c¹\Ž$S_ÿØIdŠ™Ÿòµµ5ݸq#rXžá,pïz½Ñ:"ZÜÏ£äiñlö!Ö¨K ûý~"ªX.—µ³³£áp¨ÃÃÃϬ[°¢èe޽x6Öå:ì£Ñ($fÌýõõõ#`–Ëå8\Êï‡ã)‹n·åM«ÕjâP(¢qm"ª5›Íâæx”–±êt:ª×ëÏ80kuÝ× Ìß—'d>›n°‹¼Æ‘Áh`,I4r,F ÀËã¹f9$î콤g$r¹$ƒ‹gz¯uP&Ìʶœ¸|Q`åý{DB) º\jžCÛÖ6Ït©—×WNÚuXpØÀª?ßäòå‰_°¬|×7oƆñvyýîóÅÛáýƒÌøÁ<‘àÉ8ø;pbÿ¢þg8«DddYæâí-]ο`/_ÌëåÓLéKÚã}Ç}¼$)cãïÉÚãò5¿HÌFOïÏDcì ˜~D-—¹ãs<ª&ÞÿD\ø<ïál-ý7 "i±T*éÒ¥KÁšÒ¿’âð¢l6ZdÞÛ/ÚSìí:??W£ÑH¼§†uâe/™Ï§§§ªV«1%…Äç錄}á%<½¤"Ž(:n †R©”˜ë¼‘OÆäçÌ=?tѼ«Ï€?¤áôQ§Þîéæ¶‰õÁµ\VÒ×¾Û²\n~˜ ‘ÿ<¹Rnƒ¹7’·¹8‘Œ÷_6› ‡È+Ùø<Á.øš¦OésˆÊCòŒ£Kã¼È‘w: æ}Jôƒ¨‘Ÿƒâå4yŽLž+ãïå2æû‡“kkk‰²¼^ÑÉmØêºû®˜¿.š’‚-p)ƒ—çb³sÉ›)!Ašá"D‹üÀÀ|Æ“aÏÏÏãèria¨ü"7ª øIwív;€2!à0º¼ï‘Édˆ`•a/2™L„—Ë–J¥°È.BÕÝÿ¶þãnQ¹q®áx¬Ò~OïýO[zÉaUoúà¦þïÞ8Q¹„f+žŸ I{ˆ,°–Éd¢: φu#ùÑ+ö yAúC {ë‰ÃH58ù“*Ò<„KXãÕ4ü°,Ó{• ú ÆðF»èwªlðN<†×™0ÆIš³z•J%JС¿f‡Ñ"*Á¼’‰“@~†|Á7kÀ3ϧrïÉ=$ûù†ËHa£ÑÐ[{L¿ýáë‡y$Ö‘?.ž¤Ér¹¬Z­¦B¡ ££#=ù䓪×ë:::ŠõJ ²6ÞùX£Ñˆþen’ L$j{{[“ÉD•J%lŒ¤¸'ö €Žüã ¿ÿûzý£ªx'ÙHÚd2‰û3†.©!Âèù&^ʼnÉl6ÓÍ›7uÿý÷‡K§Ó±6()É80V§Ÿ~:æq¥R‰5wôb IDAT||œ°%D‡yÌ#/1x||²AXítz~X›&TTÁF°¦ v°”¤dÎSjYÌv¿ß6iš'n»&‰ÌÑÑQØ @ýùù¹šÍ¦:Ž.^¼•— 8f³™Úív€`¨rýÔSÞ…ñã0'¢AÄ©|ã “hXvP= â4XÖãÆÿI®½}ûv8~ô!Žö›òÂŒ-ïBÄŒ}&“ÉD>Šç¯0w™K~ØÎ²&oïêº;¯˜¿.—‘¸„ÀæIl>g@``ðì1îR²Þ²KoØÄy®´Hxô/¿óÍ -mjµZ±°ÙÁRòÐO4ÄèÞ84„µÙ´ƒËûÑö³™PER€  m>·­ßú‘¶îŸži÷ôÁɹÞóŸ´ôyi8šH¹¼Òéil°‚''FÝ+à¸Ìf³D%Àʳ•|$r8p--µÑÜ$þÁh9Ó̽7Ÿ#l~ü½>R+¾Ì-)ã‰ÜŠÕ“·Ž5ÍÙdyôÆ´‡}<˜ ÿ`Ú¸è/ HyÜ¡ƒió =^¯|ùLª^à<ßÿý‰ð¾Wª Ƙ5G„ƒJ"è{=lî2¢å Yc‰c””p~©äS­V#Š…¾Ø%_ûÚךLæ§“"bµóR¢.\ǃyÀ3kµZ´“ .DÿXk€G—‡Qö“÷eŒ™OØÃÃÃøGÀÜ¡DÂCŒ³(o6›™À‘TÍØA ‹àtâ½½½˜“nÑÌ=œ 0où‘’ñx®±æ$îétQIˆwñšl'˜ûœ‘ÀØ±Æø?28À>ëommMëëëjµZ’æ ü¥K—ÂqåÞ™LF­V+q2n:ÖŋÎ8CMÔ¤ÛíªßïG¢4ïBí}Þ×Éœ%ö%€m:9‹;bgggªT*‰$ÜåÈNùp8ÔÖÖVTDb ÙóJ¥Rkkk‘ßÃ<&B¶¾¾yk>>Œ³ Ø ìf«ÕR½^×xÏfä` Žæœ6¢‘u–Œ„A6|!t¶ü©€9eÓ`sd#ANòŸ¤DÈÕN¡Æ5Ï&©5ö³5îöôÒ‘¾ýÅ==ò-=½ ' ŸÞÑ›c[_>‡ÑfCõïΆšÉd‚™dñðdæÑhL,÷f#÷„7eØK’9RhžýÿhKIÀå>üUg1/ؼa¸ò8g´QR8M0YÌ7’}asyo6y~îZ["HÅb1tëŒ÷$rO/9I»œéç?ž@ˆö—çûØyµä°ŽÌ5äD´(e‹PÜÜÜLD° ‘Ìß\.§O}ó7ë·?ö1}äá‡}Κw‰¯ÕB¡§©¢õFr‚“ÃÅ}X³Œ È ¤Q=êÏù`¼ø €x6›é³Ÿûœ¾û»¾+JOò|¤°ÂèÐ]ت¯ ýÆñ`Ì?æ‡;žDqp:GrÊ岎ƒ)enøÜ‡e¥Dâx<Ö¥K—¬1vÂ#RÌuÈä7¬ "M¤=€PÞŸ¶à2ψÜ0ÇXÏÌí~¿Ñ…b±˜¨:Æ¡IDAº,Éå cÖ¥W büÈ¡qY&dµðɧÀžb÷½ÏpLyŽ#eY‰l{Â2{ww75∎ŽÇã`Ø‘=BÑ×n__ÚNÄ…ù…½Ã™d¿@ŠÅœpi+s “ɬºK¯+W®hUxô¸œµìÁL³áI céI¦žèél–KD¤….zYÚ"-ô—lnC×ûaàøœëW=²°¬ÑduðPb>Ÿ*€v6!ïd2‰hÄÆÆFTÕasä½a™M×çRîÏ:òHÑææfD`aÛ¼”%÷’:êñx'G.ë¥çŸH€¯l6•p€#¹$ƒyG_1ç¦Ói<׫ãÉòµ°d®KóÈ € "~a¾õùä§>óÙ{ùÙÙ™F´ËLjªW'''1Çø@‰wBÎsrrXHJˆ@ùü¦ÿýEæÎ"÷b=nll¨X,ªZ­†&ÞûÌ¥!DRÐs×ü³Vœ}çýÜ&°NgÐ/Ìyl-¶œwæý);̼óH!•g¡9¼;äÎïìùN¼¶d8†síR<æ3L5÷ÃYÄÉáÝI'âK»8œ `ïÕ€°7~¢x:àOu!ÖjµÕyNOOC>êQb½ï±Ø}։ﱅÄòh ž-ÇjuÝ=×Jfs\žà°cóp„Q€!pPM`ÂYIÅc¤aÄ\B )ØiÁòIŠMÔ™³–[[[ c X„i…M‚d³æ ©jµš7H‹Ú’§5ÒW$·±áU*•Ø(Ð$³é³é›Êèíë”Ú=×÷]LëÏ®g4¸ã Ð^Œï²œ¦'„Í×ËÁ1¦&ð”™sv–(jî{D)M´HCH"ƒA…ÕGNBû\Š…v:ÆFï›LtµZ ¨WÞ9;99Q©T `é@‰þt7àŸC“˜‹lðDZ–¥XÈT\Žá¬8L>›+G`”¤Hs~*`sx’ç–0{°õ$—…–xN»ÝŽûñ¬f³÷i6›ªÕjšN§zÅË_®òÙÏ*•J%Ö.•>¤Í RJ£Ñˆµ#NûŽ’Â¡F#î 3Ž9ß§ÒUwˆPI}6íý¾—¾Tkæl"=alq^° üÎæ63l”—á½}û¶F£‘nݺ¥¼à‘°Š3æN'Q<¤“É$’Ø ÉZ­?ßÞÞV­VÓóž÷<=ùä“¡!ð²ÞIÆõd|æ6 ‰·Ò¢ŠÊÞÞž …B8\Øæþéé©êõz8 ¼“f€/ìë›ûœžž†­ðvâE¤Ï Q8)ÖçG‚p<¨ÿ¿\è»Ì}µ¶¶£aY;ôR?$ G© ¹DT¶a¬=Ntçb‡ ‡a<‡d2—ËEIZúúää$Qig ë2—ËÅ¿‰ år9íîî†Ó°ºîÞk%³¹®w½ë]’”Ù³Q"aQa308Rè\y虇3ŒlÐ;ú½ 1Â’ÃÜð{Œ%`ÐèÙýo€®´¨ü ÈTxGŽÃ†í£’RI!ÙàÝÙhþÔ…^¯k³'}ñki=¯¶®Ïôm;#}ë7*÷t]ÿçñH¹üâTÁyIܦÓYhS ÕâHPÙÄpóhÐ}\œ¥R)ÎH¥R!9p ßÁAqí&‹#úÍ5ãäR8cæÌc…ÓÆgèk¯P")6~¢Bc3Èã>€ÚzÀm'Ÿ å2‡Z­¦v»}@ŽwY__×?þÀôÈk^åþ˜oDê˜ßHQ¼Í°ØÌ[@»ä+àÐ`—èçK—.éE/z‘ªÕj"Ÿ>qrÀíÉœØ6Øhœ ä>8Nä.àøx4Ç#GÇÇDZÆÐ¹#Ÿ“ew]ǘ‘ ŽÓFÔ‰çxîƒ;cÒ<Çò"„þÊçóž·.‰$*Áœ'Ç€è GúŠ=Æí´KùS("zÂïé ¯\T­V,º=Ÿ€H)Ž:Ñ^äP^R•9[?™L´½½ù;;;êõz‰rÈdËÒÁL&Ÿ”ãtyÁœ!æ•´\âXî%éÕ¯~µV×Ýw]¹reæï…ëÝï~w8gÖaQ°"ü£ḛ̂'ê4€nX1ØÎLÀt -äù-Ø=ÚP*•ÂHa¥¤ä±í0¦o—ÕxÀÏ÷q0Љ^üŽþ”FëÁ3ýÂcG*ü?ëz¼UÖoiª?øóªïëë¥;#½øßïªp½®?즥TJ©”´õï]ÓG_ÖÓ]‘žLÂùàdHO$f¥ïhËq2ÜY®Ê‚6Á-H'lx˜—d-€ù>Fn6uœ~†D‚ˆíèH 9 mägF6b{Ú Ð8;; ` XÀ€í=99‰9 pBë óæN”¤`u?°Çlü¬!/åˆ<‚5À|ìù-kg‘ZàdÒ^œZw`™Ì[ÖŒ°¿Ž”¤ËÙlVŸûŽïЯ~èCú‡Í-Ÿg}àÄd³óŠ8€vÖƒ´(wI"" G‰±AÖ@ÄY‡;yØ Ê_Âôýò?¨¿û£?šè:a—¾á¾A/}éKc<=ÀåƒDqà)±‰s‹­c,hÓþþ¾$é©§žŠwA—¸g-¸|Œù€rÉžÞ‡Ä µ4OÇјN§%ë²:Ø~ú 6øìì,ÎÁÉpYùD‡H øbsØ?<§ Ø«”á ÐÇîtéüü<œ"A¾Wð7óžqÆ!‡…Âaçóô-Ž cÉ\À–f25›ÍX§ÌCœÈå¹IdDšeTH»³”N§uxx¹%³Ùœ¸Áî9Ùutt¤ÄúúzT¼a£y'Xy—Ò'<畯|å_ ;¬®¿×J3]Îdpù ƒ8svÚå’žñ X0;bLËúsyβÆ^RlÆ^'œŸ/·Ÿï.ë­aj—kgg³Ù8ñ’ûó¾ü@ãïéíðÇÿó3=òÊ[úîòDÏ­YÝïqV¿õ[÷éïÿ¿)=Ð;ÞrM?þ°4› õ ß~[Ÿ~ùžwùD?ùyiéžm¼ÆÇÌßÏ!˜JÆÙûkù=|Nø,ô)ãèšsþïsˆ¾ç猃×ðFWëó‚9ÃF·èŸ³Ùd­nÆÄÇØïås`2Y”µCª‚Žwb>ЮÉd¢×?ú¨>ù©OÅçèw*‡øÉµÕj5úÀûÙ£$hÞ}ùúõõº|¿}Êõ«úÞþ¶·Å|Dû¸ óø?ü°¾õ[¿5$#Ì!úƒgz2òÆÆFT©ñ1¦mÞo_ùÊWtíÚµ(KÉÅ9 Þ¿´Ë+Òx]~wŽ¥Åzóh’$]¸p!q@T¡P9"Ïu‡Å¥Œ¡Ïmæ_½^æ™g{ÿãÈø\äËÀø ÷òË× N<ýá溯/·O8yÌÆÀç ¯mÖ‹Ï/Ö}ËüóÊ5¬쪤X þ~Ø&r-Üöð=Úà{ãÂÿ—£¿Øl$óŒuäïBùP·¹«ëî½Všù{à‚m’L3Zbt¨„" ±ÂÂÖ"‘E”5Ü=aÌ“©$EDÀY×SB$¡æÛõ‡®_'ô\¯×ã°7È`PØmg³ÙHB‚9cÃsy ÷ÅÃÌ%€íUj¦›ç’4уլ¤EBèt(}òwî×L7ô³/:×ÛßøgzU7¥­Ê¼þõ÷õ_<ž•²‹d`J§±Q{¢}„Žu0˜1Þëõ‚Ù¦æµ'w²ñM§ÓWî]*•â~©TJ[[[Á~"õñÍÌÇÙuðÌæ‚3å°WÁ˜Ââf¼½T*ŒÙÉÉIBûìÐFyW¢~ šWÃ!´¾œg"8Ñ^X¡s“˜7™LtáÂ…`?=°lâDžüô\@ óÝKËúxòo—i1×3™Œ:NÌ•ÃÃÃĺ‘”8AöS¿û»zý£FôŠÚáãñXNG{{{1 Ò… Öy8ªZ­†}ÁyÙÛÛ I’^úͼ4<´Z-}ìãF߸¼ÙlåÕ«Wõøãëøø8֕ׯO§ÓQ!ëøø8áð2™gôÝÚÚšööö4 tóæÍ`ma‚ù~£Ñ6—äeg™{¼#Α‚ét `Ú=׉Ä`Ú+Î\J§%Hs¹œêõzDA°{ÅòJ2º>ݰ˰—¥R)´Û¬‹­­­Ä:u¹@t<žçð™N§%@‰¸¤Óé¦D° $yòþ”ý¥Ÿ=¥X,†= ï‚}‘ùŸïðî.7rÝ:ãÅÅÿùœ“#ìKDà§­­­ˆX±O¦ºí@–ãyOØlÎóÒéÕu÷]+0\®ñ%üæ•=ÈaõcD|Ó tÊç%ï@ÿvùƒ´(-H¸ЀCÒñˆ{’™”AèɈ3ív;¡ë¥M„21¬´à\*•bã“”8˜HZlj€ÓùçÒºÝLK—§ªW†Ê(£ifQ»Óéè“»_g§·õóß>ÐVe&)£ö¿? ÿRVÉ4B£€G/@Aû óÃæËFCÕÚèýȤ4"s‚Ä1/Ž!\ÚP("qÏǹ‚—·ìðoæ{KJ¼¬r¯× €À¦ExÇŽq`ÁÂ1×$…#*)À¨3¢ü 0ÄÁ“æ’aáa(mh»Y_žk€# øÜÞÞŽ±šÍfQ½£Z­F Q¡Ÿ¸//ò(ôùÞGGGêv»ÚÙÙ‘4O¨DêAŸÀ< ï‡yD£ÑHŸþøÇõÈk^ú^êv³Î)ÃX­Vã¾´¹kÉ£+‡‡‡¡S,Js wxx㎞ÝûÿÓŸùŒ^ÿè£s»u§ Hy°98›;‡G=ñÄzê©§Ôív5 â %Æc:ªÙlÆsg‰uH9@ˆ‚µµ5õû}µÛmÕëõDéE `ãàÑívµ¾¾L®¯¿~¿Nª3Àb™Ÿî81w¨¦EN¶Ÿï-Kå\v„½<== g5P(žQz”œ€²ÏØðN§£Z­Q"æG¯×“4g¼‡Ã¡¶··CfEYK˜m—ÿ q˜#Ýó~§<_6Ÿõíû“K;! 8¬ {È|dìØ·®_¿.i.iâ³ãñXÛÛÛ‘·Òjµ‚¼@ŽCùLN-îv»aÿ³Ùlì·8oD(ÕékÒ‹5çùaì^ huÝ}× Ìß̲¤H²ƒô°§—udsñPYþ’ HRyi±áðYŒ,”ƒq˜v  66adan<é› Tl0ÚIÀÎ FFÖ50i°`Ë¡Vú– a<©ÙLKšª^¨Úî0^ÁÎòú§Ÿ¹¨ï|ü\çbZׯ–ô'§e6²ÒGîçј(úªßïàrÆØ#'Ò¢„¥ër%%î+)1N1œ×j3þ¼Ïó±ÈfçIÑhz]j‚ƒ §/qî`ñy¾kUií¦rUUh›¼K$Ežm슩ÏN›h·?›5 )"4ô  ‚Þ˜÷ò½´ËU\“KùIÀ¶¯eæ±W\A|âàÀˆá>H `>ùù«_õ*ý¯¿û»zÃë_ù  @· ðåÚØØí/cO‚ª¤ÈÁ¡qÄ„‘¨]¯×cú3ŸÑ£¯{Fw4ßDq`IÔv&™¶9ÃÏç™#^¡ˆþò1âç^íDZ$ŒB$ìîîå>D´¸Ÿ—®Çá”!gÁyð b¿°WÇÇÇÑGØ;Œ"Ã@>BŽ ýŽ£ˆÅƹ½"RàûÄrÔòÀhé},€åÉÉIHè Apö!jp"Üñ^ž÷Ò"™Þí cØzÔc2™„äÅëÖó·Ëº°EUĆ1Ï …BŒ¡K¸Ø±_8%n爸f2™¨nDÅÁ¾ò|ú„>óÊW.=âgË9`Ë’ÂÕuw]«Ñ½.6»lv~šªX/{Æ&ˆ1ÀáñKJWï‚¤ÄæÇw}ƒÄ葨'-Né$A‰Ÿ9àê÷ûbdSñ¤*Ø"/Ó%-ÊÔáHL§‹²pnhù?ÕYØ@©ÔÃf}ÿóÓúÑo<Õä4§ãÓu]½=ÒépÞ?µm©ÉèüÎÆŒ#2gw†:¾‘Óo>5ÖúúX…¢|D6jª)8 t™‘k@Ù,Òç°v®í„¹‡ñøˆô¯³`Äð±YâL1‘K9ËÏØI Pâ§.öf!‡!Á3’b^H‹ò€vÚH¤‹{;ãåò6Jæ8Ž›?Œÿ|3™»uëVDgX­VKŸýÜç$I?üæ7+{Ƕz˜ç΂"G`ŒÓ^¯šðN§ Ͼv&“I€túƒ¹H„dYçüœç<'lk@Y±}ârVI!e2)H’8¥Mi'L6놈 šì= G[ïÕŽé”z<:: â¤R©$"o¬Ët:SÁˆÃ¸Sç§'÷ð¶õz½X;°±;H…$…ÃÇ`ðO}Øï÷˜.ç&@`¤æ3›s…ÊÎгq’Eè&«×ë…ƒçUkÜáÈçó®Ý™aþ!U‘Þ#N‡ÔˆÐ< °âŒ:¬ÒJ0ØühýîÀ”°5Ì6,±G´xorDÆãq°þÍf3˜=r’æ¹[[[1×8„Qå½p9œªÑhÄú4ÓVÞǃþb{"&÷}Ëcé×?üaýÚ¯ÿºþóû15qÁ$Su‰yM¿¸­H§ÓÚÞÞæ Fpâšn€ük臔¾cOån7677uppÏq¶™ùY.—ÃV@ÐÅb1Ö ŸžéÕ¿N°Æ¼;z° 8©®¿fÝÑô ó’r£¬E’q;N¬ x‰8IºSÒ6eX·Ø^Úˆ~ô‰ÏÓ6ƲP(èèè(öt}­M§S]¾|9Þ¡ÓéD…ÚÒívÙC"Çzît:q?Øm—uB0‘ˆM¥(æ´GùƒASFC’´¿¿¯\. ÀD±˜Èjx6¬> 7ãÏžGùþéå5ÏÏϵ¿¿¥C}-¤Óé(ì‰Õ¬ìàþÉ}+‹ÑgŒE«Õ §²Ž½¶Óé<#²¶ºî¾kæïËå è•ë€IQO˜0h§ÓQ&“‰„-B|^^ÀÎá!ML×Ëz•˜Édìßc¥}’", Ø“Ò4°°p€À÷ä™’õЩW~rr ™ƒ=@‚„|$£LîD¿ñ©Mý‹í”ökí‡Ú¯MußæH 3);Ô÷|ãPß³<³œ>÷»õß<‘Uóä$¤Blr•J% rHÆt½$ÿ÷0³oêËšÉñx¬ÍÍͤ°|ŒŸëÑ(RòTHúÀsÀe Ò‚÷Ê0ôp´ƒy Êr¹§2²/K\há{¯ÑŽŸrqlôüŒy6›Íâ´H‘ŒÁx<Žˆ‹ápšq>K;؈Ñð²Á Æ"€ás}ïÖÖV”¤ÐçŽF#ݾ};œ%"­V+E[$2#Éd2Á&£SÇxmuœ(Ê¢â,¼ùMoR¥RÑûß÷>IÒ½ã‚OIqPzzî‘N§¤L&“û\½z5έ­-M&óºÜý­ß’$½æÕ¯žÏS«8'‚!)J,zol„'àrNÄÑÑQÌ‘~¿:w¤4ùü¼6:öÈuÛH¦8YÇ®ßïÇ\uív»‘zóæÍ`x!1ÜácnÁ@'~ýúu ]ºtIår9jÛ“4êö{Ð_ÌuêÌ»³ƒÄ‡ŸH'ÀæLju@ôb{{[ù|^ßò-ߢZ­¦f³©Ïþó1ÇÙop¶IÅŒF£He/bÍR'žèsÙ£[ôÙÕ«W#–È‘—=99Q*• ‚§ gÆ1ˆ">N'œ$cäÉ «Áù`uG[ iÒl6CŽç'Ý®¯¯«T*éìì,tõØCÞ‡’9™ËÍ™¢Ï¸'»=]]w÷µó÷Èņëåîr^ýƒÏ¹F’Ës–//Ë“á%Ûür)-4«6ÚO”p; ‚5Ái@‚!)6f6$6[Ú t†Äïåšs˜®ytÚÈésÅØ˜‘ò¤×‡ú•t¤—f3úìïoêÚÚH—j=´5ÖåÚTO~i_ÿàË)õFÉR°7lH.ƒqöËu°>>®›v°í$׳‘zlŸ;Þo7 synqñË~ú 0Dx–³‚Ș±Ô IDAT?$%"JDhãòEb!—k}é—'qO€·³~|æ °GËׄKÏô—G³cDFoɃp¼KƒÜq[à¬úò4û³}Îv:íïïÇãþTœZØÜópfé«åh&]?‘Û/æ=¶Ð«¸y{¹?9+>ßx—ÏÕjµXßD2©LÃE»}¯qi À>tΟN/N1Ç~/}ð1$1›6¬®»÷Zî=pQ9¦Z­Fb•4gqNNNB£ 8ñƒe–“‘b–A÷†ñƲ‘Ä+ĦAbëh4ÒÁÁAb“ñ$?*±Âl¹$ÃG€v¡A•”0pTláû0òÝnWÓé4ä 8 ´ß×røÿH/­I·ÿdCï:,Á —ËE•×ll;€ž¾÷JÙl6QÁ€¾àbƒ—¹ 8@X{½žf³Y€€r¹¬f³`ËK¿Ábrðcæò#ÆEšƒ‚f³›<Àœ¨Éh4ŠQ¢08fÌBß’B†À½™‹l¼Î6ŽF#5›ÍOßJ 6GÀŠsÇûÄi#óÅ™T@_½^~¦Š >Ÿ?== m3àÊ×àƒM™ ãÏÃ: óšâüŒuKùÉ££#]¸p!Xñµµµø;¬€Z¢Oý~?@3?w'L’ÞòØc!úЯüJâw?úö·ÇX _‘%3»Ý®Òé´þñ>øÞßð†…ÆüN%$Iª0µËàËÿO)@ú  NŸâœ0ÿ±$¡â€Ð/H³ÙlÈõ`Îé3ì @'eI9½Ôuû¾&¤yíøL&£n·«~¿6‡6!Ä–Ÿ…ÃÑívCûÝjµâÞÌ]ÆÍÍͳa/˜{Hh¦áD¹ÀIÂîaét::??×O<¡½½=u»ÝDå/2²пD­¼Ì,•nœåFZvrr¢ûî»/ä;´{<ëÂ… ßh4R­V Òg4ÅáûHöÜ!Èår:88)ÀÐ}||¬Ba~(ùÌ7¢6¼Ÿ3þ¥RI·nÝŠ½À¥2;;;ÑFì(ó‘@LÙTr||ìX£H‡ÈÍ9;; ¿;§«ëî¼V`þ¸\“‰tiazI‰ÄG6rgfؤaq 0(^¿XRÈDH.â3hŠþÔlw‡ì}Œ8íBø\fƒú°cHQßÎd;Ëík°vF£‘Jµ¬¾û›ŽõÈs‡ªŽ¥?ûʆ>òǺ¡|À¹ÁÏèOZ’j½ 6ÓZg!g¥bS””0²€?~ǦAÄ‚Òf€CØ Jãq²íx<ŽÄ(¤úe Ä;;;±ažÂðÃd,ØÒ<BRl@€SXH:Côíô=¬ºK¤EUØÐ¸Eµ~¿‰›8C®•—‡â¸¾&&Î5@C.— GP')8úÞóFx.‰i8 ”gÄA#lŽîÖ™@d€Fœ wjx}!)ÖµºT*¥J¥É}­V+XDæ9ó-: ƒ>èõz‘Ü8õ–ÇKÈ~å½ïý«Ì‘$éMo|cŒC6›UúN?MC67›Í¬bwþ¹Îy[pzz%Ý9›N5Ü 8Ÿ<‡¹Ž Þ`3È…€]>[Eî}LIPiÁò¶Z-e³Ù°}8lØ›l6«N§Ò/l7kBZ”b-‹!3!¿6Ÿ¹Êç<’„§ÑhèÂ… ‘ÇÂ:ÀöHÒ“O>©7n„ü‹’Œƒ4®†qÄyƳ±ú8$ŽîììPgŒËŒ!ÄËÍ<‚Èšr9s‡ýR©Œ6zs':¼<0cÅ|À^c[&“‰šÍf€x£ñxóÀÿH †5=NC÷ŸÏÏOˆ…”à$Ywºwvv´»»«§Ÿ~ZW¯^µÿEÈW×Ýq­Àü=pÁBôllÆh1,0²l^ÑàBY2Xâ壯ý{Ö—Ù5¾ïÉVüŽ #ˆÑBgLÒììö˜ÍføâPH à€áŽhÀúmýOÿÙ©¾¿´èÓo¸¯·~Ϲþá¯]пÞSáNÝöéTºv##=g¢û/åÔÿãŽt‡írï))Ø+Œ¸'€1f$9•Ëåøœ'ÒÒôa«Õ †–ÇõÕè)qÈ\ÛÌ|ÈfçUt H‹ò¥Ì62@0‰Æô1Ì<•BH„•Œ±3ôPOd–@˜Ó€U6-—?á`œ©×ëiss3¼¤s£Ýh¸3k](T«ÕÂÁðÊ8ô!óÐç¥áÜ»êõ aèS‘Ûáɬôήðg<`d7.gòIð8’Ô|ÑNlÂßÿñ§™l(ÛHe•áp¨Úg R{ú)¥È`$ûý~œ¨éšiêÌÔ‰3o;NTáÉçó‘câŽ:útÚϸ⤠‡Ã°•hñ±­N'l Ž¢¤8%§§šõŽ}°âBÒé´šÍfÌq˜ýT*cŽÃFÂ.{çPĨù´ƒ=Ûâ2!#ž‡­¤ª÷÷¨9f;;;±¦°Á¬ö˜Ùl¦Z­ý˜Ïçcn`£aö_Èwö²ÙlÈùø¹Üg4𦶵µI¾½^O×®]S>Ÿ×ææf$У§_]wçõLñóêºë.6L˜®ñxÏ5|€g-¹œéæ>lž€s¾·\ P‚ýr)¿£$ ÇÆÍ¦ìϦÝT1‘››4ßœ\PåD´@))}ç»´1•JiZèèçÿ«;@¾SÖ{?õ€~ø×·ôÙSIåýÌß½¥¬¦ Dæuãæü½v/Œ•ºŽ©dÁ{˜°õ°¯Hèk$=l lZ0·ž4Ìg—þ¾€ @ÈÐ.¯~sI»¹mŒ óðÑ\FÀzû˜K$¼1wxL8l5‰lÞ8%ÎLJ Ù@Kòi›ƒz€&›ªË“œág-qñyæ!}æ1 i ãC»#ËüówAÖ@›ùCN ƒgår¹8·'Ã×÷ãàÚGÍuÄù|>Ø|—y‚.sÐË8#ÅÁVÐï$ÔÉÃùF:´±±¡ÍÍÍDŽäVæ/ãDÛ‰Æ0ÿü{Ê=·[ÛÌxp!¯ò9ųx_/%Ìfçe€]Î"Í>‰­Ý–? £D&ÑÆÕ®¤Ínkh7}O é AÕë´³®ý ¨^¯Q6l;÷q‡‰œ"½Ìÿåü ?›½‰³¾èKÊ\2?Ž!?a?òD~ìkJR°ßƒÁ@Ýn7‘ìŒÅÉdc¼èìö†È7$ªá¼ÑÄb_Ã1òh ûŸõµ ©E)T"@ì%5üŽ9¸ºîÎkÅÌß:RŒ£Ë Ø„@®Ðãx3ÉŒþNT•ad^ü†Ãa¼«÷­—f%ú!)&´Ëgggš)³ÇZ8#™Á qò1Êr–J%hww7æþÖÖV”Â<>>Ž~ÀQ:==šäD%xWúV'›µ‹ä§™úòèÚé¯áp¨Û·oÇ}ÛívÔûv†Ÿþ^__׿æ¦Z­–vwwÕh4l8¬ôriYj–O&FT¥\.'NDfLq‚‘àÀž3N^ÎÓ£.¼3 ÐícÃæ‘ç@D½4Î+ãB‚5ó{Á¬úÜM§Ó¡½?99‰’¤ãñ8*ÌàxJ {âºì!’ª]ÁN#_C·Ï¹8«Ø|˜f'^kŒ÷"·€5¹¾¾ù;éô¢~½GܦÓiâÔ^ò<ê‰ô çðNDˆ(1û"‘-J•RqÇå\´©^¯Ç}!zÒétxH3¶8k1ð|…­­-½â¯Ðêºû®+W®¬Àü½pýìÏþl‚)ÂÈ€ðP²©{8—DT€›¨”¬NžHÏåB2Ö@àŒ¨³êu—Y@¡\.G8“ZZüáºûiúL¾öª~êá©4ÉëíA}ò´$Ý‘.¤ò½í?êéR»ªð™‘Êßz¤O¾ú\%¥ôå~YïË:™Î”/õ¯?Ð;¾Yzü*º5,êŸþÙH'ÃQ°"l¢€AÆÁO²…±¦Ï©¼u»éÂåÎKsJ2 ×Vv–Ýûĵé^ÆÍGkkk+q¢ŠÅbl(°W$ߺæù†ƒeÀ3uÂaë™s€3—OÜ\w̽˜Kȳèu£+æýyOúsX ã ¼ï5àýÙl6˜m€úúúºjµZ0€$zp*\ÛsÂ6dgA‘gpn‰ªÙlVÍf3*ì°î(ì!zÖ cI„ó·®cPñsrˆæáäxG£‘xàX£4q”Òétœ ë`Û% Óé4"Nù|^µZMÝn7˜wg£i/ýGU+æ»;‹Ò"_Y ’Žb±õÁ½$ÑÁš#WÐJ$ÎõÒ/|á ÃöÎf³8¹Ò–•²‡8ñTœ¡ Íf3ª±`KªÕjˆä¥x±¹ô#ä`ù˜'uò{¢qœÆŒôc:ªÝn‡ÄÅÏó¬t:Õ±ÆãqDGqdqàYëHi|ŽðÇeV."·‚¤{Æ {Â<Äa¡ÚšËaÅÙó'îGî¢F.Ï!j‚sƒ­e͇C]¼x1X}Ol÷ýŒó X³þ ˆ/ãé9G8¸‘‡õªW½ê¯Ä «ëoÞuåÊ••fþ^¸06lN€>.6RŠW°á{€xgÇ ƒ²YÂZÀ‚ùïÙ¤E .w&ëãâÿ_oú&Vpy¾ñ®Õð¶Ð>¿§³‡ÿîòÅz?x¿y?ñîLï_ þݘc6Öþy×# AÏ Ëšãž^WÝ™Xä~Ñ'·å/;öÝŸÑYóoæ%}Kò¢ÛØ{Ú†<ÂÛíóÆçcJ’{µZUµZþç§fò™åúüËóxÙvxŸøøø¢ Ò¼Ê ïÜÉŸÇ;ó$µúX.÷=mòg3®¾Žýó¾Þƒ:N¢ßü}}n1_™³Œ'Ï¡Ï}î²ö¼ß)Q¹œ¼L¿ù{úü –•YÿD—¼Ô(ïÊ\â™ô ÏaÍr&Ïò²½Ü“ý‰vz»èW?˜~pûㄊWYãoœï¿H4öùævÿ»¼7ò7ºúƒõüs«ëî½VÌü=pýÜÏý\°0®e&< k@(FÀõšh?=ù”ïy2, L/BIÁ@Ѓ¡ƒÂðÀPU*•`[<ŒíL§À ‰ò\X ³³36¤·>v{ä§9½ë=5½ÿöš†wÞ…ïžÕ©õôÆKC}çó&*(¥Ç?¿¯Ç>?•6JOFzào]×G¾o¨¼rúŸ?RÓÿ5\°Ö°8J^¥„¶V«Õ` ¥ð¤ÐÑh ;r 6!Ú{|| ± \ û˜ÉdT«ÕšÏä2°ô.wñÄWÿ®—æ”Rd 0L®éw–vߣE‘@£Óüm/`œú˜{-Ër¾D~h3¡wï7i!M ú 2æ0l¤;ÊžgâU ÐÝÂÓ÷°~$m¦Ró®hÞ‘ÈФiÍ̬nmmEBŸƒ{ú‘1 )9è –÷‚ñFóMD6—ï"%`<ˆRd³YíììDÃ4Rƒ„W@Îl6 y ã‹-b.•Ëåˆõ W!—ËK ïÎD"ôG6› &ž¾Â†1>¬ÇÉd¢b±¨µµ5Õjµ`°‘“yô ½ù`0P¯×S»ÝV»Ý)–ËQ¡ˆ*>ÏVU¦ÛíÆür¹‡Kcˆ³ÙlxÆzë¬}Jâ€Me¾šOOOã´Òt:g.<õÔS1‰Td³ó$Õv»­Á`gœ`[¨¸ÂX3ÎØIr*xŸ{Øäa´›ˆ kžï"g£%2/Ö<ûÕyòùùùH¼¼ÏÉ-©ÕjÕT{NÃÙlQ0œ ì¨ ‰þ?•JE4‡’Š{¸MÙÜÜL ëëëzùË_þׯ«ëßýëÊ•+«Ø{åÂ(’áÏ-)Á&z!šm?‰ òºçžøx¤1uµÇãEù94°lì°-lâ<ƒdCÀÀ$—ËE2™Wÿ›$ŒóZ)¥·ýÈMý£çÞ)™žè»^°¡_þÂH£T:@Ôܸôç_ºOÿ䛞Ö+Š’N6ôk’—ŠyOšzÕ÷é§¿íL¥ô‡Ÿ®ëý·fÊn,Ø4Ââ€Ji!I"!—Ë…<Ãúã.)’ÂØd×ÖÖ"¡l:j{{[’†ž‹°,Àǵéô%c·¶¶ RˆèäºicG¯à°d,3À#’*þͼ¥\$:]þíLTwú*•Jèe³Ùl âóÓû Œv»C˜ÃáôD4ä(Èš¨¼±|Hó–$H4øgÌf³D¢$ºlúqoo/À·Û æ9/ÜÓ%Œã^.—Zb–W¡Iœ¥B ãÄ8À0"  vG‡b?þOß‹E]¿~=æÂÑÑQ”UÍçózøá‡uttçOüy'˜X/}ȸV*•;8Â8ûžoàó©Âh4Òññqô[½^×p8T§ÓÑh4ÒåË—uõêÕ >pT^n—±9==œ—yÞ ý )‚ã9 ´µµ‰þ…BAF#tÜ.OÞàôg³ó¤Td)¥R)’kŒŽŽ´µµ¥íííÄ~½&ßb<«Ñhhww7"Œ5 :}@â, ™C~‰3ÄŸlv.‡cáøÐ/8í̾ãÑ ¯Ž4¢ô*ë›$m·÷Èüp˜°¡e¯dnø>·¿¿óßÃÆ“ðÍœ¸páB8®^¡Ë#î«ëî»V`þ¸Ø¨%E›Ÿ3WþF³ 3Ï}ØÀÑ*úÆ`s’æ,‡;Ž!sM4Fý©³e´ öÃM»r¹\h8°Ñ†ÑìToÓÑÈOÖô‰•Ò~ó™^òýOé“ûõ÷¾\Ô¹ày6›)5ØÔ÷‘‘jo9Ðß.÷ô‹ÿuO烴r…©î@@ýáÿ±¯·q¦Îø\›ÆøÂ”Á¼I‹#èÙqN`Äèc@&}3 ñäUIQ‚@îziØ%×gcì)+ 8`À}n8;ÎåzXÆ‹9ÀósOþ°yØH±Yyò›¸Wx@º‘ÍfC·Ì\“ì7›Íb^zb#àÕåËr9X $––Ë嘟¬)>ïÎÛr2%Ñ Ú謠—%Á–ïP·O.—SãÖH_|r[õž¾iwªbv¦´¤ö­Š~ñ“ûúþõ††™lâÚ(å½&5L/òΛ/}廊Z@eOv–»R©ÄçÜü~<Çï6Lä^Ùi‹´8Ћ±”`Œ?¯ÜffCD6ÀçÙp3™L”hDzt†dY¤$8§0ÌèGêôÕd2¯fxb,ØÈ Ù …HXæ4OšõH2§'çº\©P(xu)„WŽòƒÀ¤9˜­T*Y€:€òJ€ 2€ŒëÖÑVöçg<'Is§j:—ýô ?Øœ¤ÌIÿß¡t"²d$0"•á÷ÜØh4Šƒr<‚qaü™§$n“|‹œÙ„ç1àh¡}Ïd2jµZšL&q(dÀ$ó7âà'îAô”6cO±³DIÜi§p@·Û Öy2™Dí~Ö~¡PÐááa°ÞŒ»kù™ëôÌ6 ’uNÿ¢©÷y7NU¯×C®‰SÏ\Çqà½qna¼)Üétâ”i$’܃ñdOð¤PœZžËZ‘sŸ÷à^Èþ°±ž, ÃYÌæ=tÖ r¬|0*í9bO`=Àâ³æ±aÈzœ @æ„si†CIdîôôT<òÈ_@¬®ç¯U5›{äú¥_ú¥%ØÔëõ›z¨Óˆ\ãçàÅõŰð€v6c?¤‰Œ‡¿‡¼ùÃFà G?¤0|‡÷À ²Ñd³Y=çÛÛú_¾k¨ì¤ Ÿÿà¾~é锯“™Ú·ëúÃÔ@?øàP=ÜÓ· 7ô{¥ðÒé´Î{)}éŠzßïWôåΠ÷ÿ^]ï{bKOt³êÜÑC¦R©DRWq?›N’´/yx›ªάxß‘v ít:qÀËd2IT@`£ƒæµ˜lã4xÂL&€ÀY\:ÿJ ö“p·‡žiW­V PHç=GÅb1$AÔ‘öÒÎÀqXk6>œÀ ³¶8À°fŒ&¢L&£v»¹lð8Îô ƒIÉdGÚ 0w§öÐYhÀ,ïÆºÁLát1†T=!ú€& q~~ž¨.¸ú<£’ŒG¡|܈ì©°SŒfÜǶ^¯«Z­ªÕjéàà œ%æ#ì= ÍmÎ2†¾öÿã|Ð&À.¶‰2€òÍÍÍ3Ï].@Gç ‚VôììL§§§êõz*‹q€@NÛ=ÆN'N ã€#B>Ò,úž~)•JñÛ·o‡´ŽyOŸr&ç÷0ÆHô*•Jäqø±t»Ý -ˆAÆÐf’8¹‡K(qüYÏù|>ÚŠ¬§Âs•ºå¾8<8Ë8û¬ÛA€˜ IDATØõ\.§ÃÃØ‹,ÈphvÉ#3Ø "e•c "?…à@"ÈágŒàÞ˜Ùl¦Éɶþ`8ÖŸa_ï»:Ñ0$!i=ýµ5ýóá™^ûܱzþ©þÖYA¿w°¦s“F„~8×­ã3uûúG°Î„ó 1c€´Á~±Q’ˆ6è+X@’û`?½OüÌ“9„ ]·4Í×V&÷·k1½^4ï<@)%+“øA8$0„´Ç7M's?6s 'ÚywØct¸˜¿læÎü²³yù?ó†'Á7{6kÆÌåbDpš×ú6›MIJ€Æ °l‚ˆ@pCßΤ¤9²±±‰ã82’"ÁÕë댒¤R©(·ÈxPæ»Â;V*•˜g©T*Øîáp¨ããcµÛíл{›Ã\¢_½l!’Xîv»-IAB oaŽÑ.."¬5ïKä Ò‚(òB Ö/6qÙæcnÓ×D‘ÛÐ8÷ØZr-pJpĈj`ˆœF™·ÌI¤T8£ì88å¹\N[[[1'}|;X`ÞÁç5Œ:‘lDˆšR© —5ˆóR*•Ôï÷uxx¨óósÕëõ°/³Ù¼<ñÁÁA”lì÷û‰’ž8||ªñ$í2Ϙw€iúŒ5AdÀežôÎ:eþ1Öôÿöü%îÃÉÁŒ3–Éd"W [‹S䤸R©¤—½ìe\X]¯UiÊ{ä‚9E³,-Ø@67–®‰ö¤/)ÇÅæ±|ԜšpÇ‚Ÿû‰°üÁXù÷¥EÙ3Þ€F‚ßçwÙlV“±ôÄ¿¼_¿q;¯TfQV¬P((›Éë_ýþ®Þþ… 4Ów¿òHïɹò“qâ]üÝ–Ÿáÿ÷þóû»ÒïË÷ýË." þ9¿<,Ï¿ ®CöRhÞ¯Y;œá¢ßÿöîåG²-;ûʈ¨|Ç#õè{[—Mm’BjM5Lè†ü?ðŸÐT‚ ’ èðØ° Áj²HÈ”(²Q}»º*+3#ßÏÈHR¿߉[-¹«ò…ªÊŒ8gŸýXû[ßúÖÚY6Óg„ÐU¨øÔôçå~Êä°¬`”Ñ£d·—ÇÉ»g©Äü=Àî{þ—Ûãò®ú@¡•^.“×ï÷¿3ιn€©LêýUã%êÐêf›²½Ëã¢ï?õ^Yv”dÊwõq×þe»á{Ù‘å}YÖðS¶Ø’`™s£ª:Éõl€$XóÄØ,·j‘ŒžŸõùå2Þiy­h'ÇœÏþ<>>nå,g³Y{ïœUOzñ,§èËë?ûO¿-¯£œßäP™v Ëàæ|È>c£Ùõ,±9›Íjoo¯E|ò3¹ÎSÚomÏyt{{ÛÊz—àÙ.6(×FÎ5ý¥/¬Ë›››ÖVí`/ÙL—9áJ›—sBg?û®u¡Æ0“Ÿ}Þå]}O_¦ÝÏÃÙÒžæ;/Ïçë󺞙ù/àú£?ú£V¢¬ªšî”ñ$ÁI¶‘ÇO—-|iÃÂ@IÞ"Íp_šüªj!nìIÉ ¹ MnV×À'ÛÎùPáB¹ªjL–ÿc•$Xb¥1ØŒp¿?¨Ãw;õ¿Þ\Ô÷[÷¡ÿŸ~Þ¯•«-ì›:q¬(&»‚Á¥ÿLÖ4E0*)ʜㅩƒcû…¨½ëÕÕUëÛ”Ö0ê©y¿¸¸hmÄZaÃ0SÆ‹4AÞòì'ríKö;kÓÁâ/—„ìõžŽgO Ž Õ×ä'Æ>KPÒ‹kÓýý}csÐÊ9š¡zíÐOÆ-áyÂz4w8_Bô)gðèvI(8$wÖž>¹½½­étÚò1VVVêä䤓ƒ€iL:§u0´òªãñ¸çY˜{æƒõ<&sº³³S++‹31Ìߌd5£ÌQñ>é¬7s‡D'iÏXNæÍf-?£‹P`ç8aœ•ªÅIÁÆÑ{“uœœ4ý½6p€Øý´±±ÑtølQFç”ÈE¬¯¯×t:mk5åJˆk;ß×|CHð\vÔ}7ÇÄ>‘2=÷ÎsNNÆîîn‹ÜÙçççõêÕ«6Ï› %w2g¼»>L9i§ãâ⢳®s_±—ÑÛ“?!-†Ãa³WÖ;Y«÷µ†3¡ØšÎµèäWÑ:÷f'22AÚÄùcÈÍ’ûƒ?øƒÿ4Xx¾~-¯g0ÿ…\ÿìŸý³¦¥¥Åº0@Š0ž„ #ÉøÐõ$Œ&ö £áP•ªj†h>Ÿ7½¤¤Eì…Í‹—wèq96¥Ã0@ }ó3˜ÐªÍäÉßÕ»?_«ÿceV?ùË÷õ[¿{_?¾ÝªÿåãfÕàEë3µØ÷d{rSˆ0ƒÁ IVh¯õ+Ö©×ë5¨ÏIÜÊ aY/ïþ6TÑ íÑwgæ$`ð’ÕK]³ÄتEMüÔPcÔªªT ¨ñ¶¹Ûì2Bõ²,ÇgCÌMלÌy”ª~K à*y.Ùsc”aôÌ9¨ªöNÛ³ÍÎ ÒÜ3§9ççç5™Lc‘¢Çöqt%[Çú{{{»¶¶¶ÚûXì@FßŽŽŽZN‚¿'“I+sh^YCéôÒß;` ¸%Jæ·ßï·¤IóÐ{¼xñ¢¦Ói;læÙÙYëÿªjzpΤ„æ¦vrRrmdù^c×ï÷ëÇõþýû6Çš3…í¶Õ‘E<99©óóóæ˜sPä'|œ}®/îîîšöÏÎÎjgg§"Wµ9¡Z Fšã–˜ŒÌ˜7%v¨ßï7¶=KÉÑqº¾¾®—/_6§ÏX‘:yVÕiÀá\[[«u’_‘‘·ÍÍÍ–Á<<ƒùÏóz>4ê ¹d@ ßï7昗cXl26¦ªëš!અ”%K¡Ù\Ü'CÕ¢ 3C“ 1†–ÎVWWëââ¢Ã¬zתEåÆ;%A6T!Qß™ÏçµRýú¿þ÷¯ê¿Ÿ}[ÿã{[;ÛÕ»¿¯ÁÚz«° M ¶Mäó,Œóh©Õ¦2 ™’•e S²á6C² ÅÆdC¥­‚â:::jÀ[§ºÈ) ês^èÿLLM§'CïÚj ÜgY/ì{Žyb~q"²ßýÞøg”è’òùUÝ(Är’,y YI:yÏ÷szjN­~||üNê”nHHÍd[ë #"úßZå'{­ß8ÈÀ©yš€S[´ŸL‰Óï;€U®å)ëëë¹gÝrŠ22ŸÏëðð°•Ö¬HR&È#óâ‡Ãa'!·ª{ šöïììtʾ¦“Æ7gô' œ¬¿þ3Ÿô)é G¡×[œÉà ®œ›úLEv’|ǽ8¥Æ˜¥J›+qzzÚˆ̺¹d›sæ>0˜óŠ£«œu'z&i †Ûx`µû§œBû’¹•ö6Yt9HɈËI0Ç´[$ŽÆ¡u¥3é=Ý3?ãs’QÙgHlØ@Žõþþ~³l¬5©?Dõ»5èݽFo=×~«Rœ€\‹Ï×çy=ƒù/à’lçH燇‡fÔÒ䦾¹¹ÙÙàl ð,Æ%3í«º:êÔMÒ­VUG÷(ÌŸòìŸ U8×Fœ%»°ÍßûÞ÷êõë×Õï÷ëýû÷­¦oÕâÄÓÇÇǦI¶¡`j«ªnoîëgÿçoÕÿp<¯_üÙc}¼»¬ÕÿX™‡L…ÇJé“ÓÓÓÆ4Û,l^˜i@ 0‡YÀt\{ŽO&Cc äëcsÖ»§LF­l@HŸ`¿°ŒU‹„Ú¬Š¡­vŽVt04VMäýó €¨Ê2z€‘Ûdî>ÑR‰;Ñ€_µƒƒƒv/`;É r/€g9" =ãñ¸1‡æVPåXÑbë(kÿ[g¢núø=::jý'’c É)¶¬c-°C& Iê’å qsÎÀÖb´Žƒ÷þýû¦…vØU:zœéÙlV>|hM.ÁíímcšÍ}óõááéür=Î{”vygg§Þ½{×þŸ¶à&áB‚˜_ȇ´)é`ÃÇt¶­ 9Ú4ëòò²­mÑεµµFj1›››u||Ür¬sïýððÐd‹æZæ0-ËÜÌ…ªªÖÏòXØ&ó•d#øâÅ‹úæ›oêåË—õ§ú§ 8÷zOò,åsÏTöÓ=ä%RþòåË6ßÌÍÌŸâÔ9œË\f ¼É¢½žmzóŸ÷õ æ¿€KBMêåmÞô«t•™T™€hcc£¦Ói U `œ ©ÉFW-€;Í!b Së+ Œ dÒ´w fvwwëoü¿Qí¯ýµº»»«?ú£?jÏÏ„Ne …bÝߦJgøÇÿ÷¬¢,i³rlàØv}a£ÖWÀh‡„_ϬgƒÔÝÇ÷8Aʉ!UO¬’ÒjÊ‚´@DF%œ¤,Æg>ujN%RX¥½½½æÀ¤¡×ë5ð±\U‡3™Î±æÔx‡LÞ͢Ò*'²žd*Ê»»ÅáKûûûzáúÃ\3¿ÓY0D©´Ãé•@~:Ñúþ9+á• 9ñòŽÁááa“(áJÒ5ÃÞYDDD `º¿¿¯ÃÃÃö]ýL^"ú”%#××׋«½í0«ëëëVÅsN~Eâ'‹ ¼×™¤ùœ l¨vb™Ig³Y‹œXÉvK¶PÆ×gÍápØ)ÝiÍ[£/_¾l÷ô}²8í|ûöm ‹SV‡ÃaË+!ÅÐ&ór9RsuuÕ‹â<#ŒM:ÆnYòvrrRoÞ¼iön6{:xÎ=dÑNN¯×ë8¯l[iüôÑÍÍM½zõªêÛo¿mÉí)Ÿr¥¬o>Ÿ×ÁÁA“Ü ƒ0Ûãñ¸>~üX/_¾lc¬ü©ñ½¼¼ì®•mýúuM&“úëý¯×d2©étZïÞ½«ÓÓÓVɰæ s>|øÐ6r!m™1899©ápX«««-¹Õ»È˜N§m> ¹\œÚÑhTÇÇÇ-Ïåùú|¯çÒ”_À°¦¯jQò*/,½K8—a΃v€9¿_¾lJYÎ Ê’—.+“—ZÊ„WmÊUOŽËëׯëÕ«WõêÕ«NIÃ|'÷Ïçg´_e{–û3Áíò»/÷ïò»ÿ_þ<]p‚çìK›mŽ™{äøTUâùŒåÿ/£þ[NnÓnã“ÏÉ PÌç˜SÙgäþdßeÿæïÌs3ïçïlS–ô<€1Ÿ“ÏÈgùÎrŸ¥ü'£\Ës ëg;rN}jI¤Ë9WU-)0×Lʶ¼“õ!Úñ©þç¸-¯g«OõÁÖÖV§T ùµ\:/mŠûŠVåœb¦åÂøYŽÑòØHžÇ>6¾™\½<ÿ½×§Ök:šÞÃgUνõ¶\ÒP?f Îår­fï“mÉwõ<Ïɧì³÷ñ³œ¯9îÆ:fìÙy}v4<äD&•z—¬Ÿ¯¼¨ï»_ÚØìïªj’6sܽóïe›k^¥-åÈšGr»hÒ«ê;å)µi¹4éò˜yf’cý~¿ó~î™¶ÆúÐŽå=D‰Ò£~¾»»Ûžgýå|Y^«ÙwËûÛóõy]Ï °_Àõ÷ÿþßoaNì/YÖ–×OvBs—ZàªÅA-˜†ªjÿWÂree¥…ű²’òÒxa‚L¬Y&ÕÒb/¹‡‡‡V•D06˜é?ÿó?¯?ù“?ie …ƱôXOáÑLð•Èö$TUÓãÚ0–+j`±ElVYõÁÏ1êY EŸc3ÙF‡ ®Z %Ú!ïÜimm­677[õg&“’Ö¸¿{KðÊ÷ÌrkY•AßšwUÕd Ú'Ò@ûéçæŒâ ÕÓŸú›6Û%4î¾6LmÅî‘0$;.ÉO?&ƒ»²²ÒdMBíú Ès3ñoee¥1¶ÆÝÆŸÕQªù$¾WUí߯`6{ªè‘ŠT6I]¼h@쾃Á #¡óyóÝ¿EFz½^c]És”3)KI‹¼ l¹È–ÀóÆ›yvvÖ˜õápØ$už!M)Žè‹ùBº%yôööéTQ¤´Id/UÕlêNì Ò€WWWµ»»ÛžineB¾µÌéI;)r±\Ò‘ä…ÍX=>>6;âáææ¦¦Ói“£°y···í}Í=Q'‰Š„aäÙë½j"ÝŸ¾^"-–ûâ⢣Ǿ'ßyElü›7oÚû‰¢`Õ½3gÇ;cÌ777[ô85ÿæ{žØF?ÏçVU}ýõ×MI.˜Z÷Ì×ÚÜÜì$䟞žÖ/ùËúùÏÞÚ.ï%×–{±§œ.¶t0´è¡èÄl6k‰çöù|Þ>wwW£Ñ¨#KKÇ?Oð>==­Ÿüä'ÿQÄóõÿçë9ö ¹ÒÛgH¹ªêÈ\êÕÕÕ¦5elßÍ0.P„»¿¿¯£££¶ØT¡üdBi^«ª£÷¶YHj‡ŠŒ¨Ðã¿ü—ÿ²þõ¿þ×õøøXGGGÍÁP&k+|Iæ@Ö2 j2™TUuNÉÔ&áøLˆUñ€ˆÊÚ÷X!NÅ|>o†šS‘ ÐÜ,XžÛÛÛŽF^;õÙ@0 æ“Ûø_\\Ôööv‡0mÎˉpÀ€ÊI`N¢1ŸÏ[•²¦d³~H¹€¼ }j,I|8bêSG÷гR‰>æÈ¤ézâ<ÕZ°¹Ò˜ÓqWUÓ9“(kgî9÷õ'P-Q“T‰< j!ÕZ[[kµÕ3§CÛ­G’ ïE#LæƒÁV¢0#?ggg ™ ÐsppМos %c˜Pýe®¹´×@ Köëúúz;áÓ:FH*Är¯¯¯7ý|>¯£££lrÐR~GNå„Z@[Ÿ³Wæ–yê2Oô?GA,Zôëëë&¹ººjRëÉÜÚÓ’Dïß"€­³¦Ói‡…ç,«“vÜ”;ð²áýþ¢Wæî°é5{²½½Ýq’Í?vœ­²Î^½zÕrMÈÔ2RØë=Õ¢ßßßoó‰3⽪ªõ3Ûµ»»[¯^½ªüàõ»¿û»õ§ú§õþèÓÓÓº¼¼ì¬ygVÐÙÛ³®®®êÿø;öÝwdÍ(i™‰Ìyª³±fS9\Ú<™LZaÒ›7oj6›µr§Y<À8²}úáSÑðçë󹞙ù/àúÿàÔl6kd2Ð6w›`¡Ãj@0Êp`b8>ƒ7Vä>ë½lÚÚhŽûƒ>;;këÆxép¥†^{0U ‰ŽM=£'ÀFŽŸ¶Z‡’êÈ3ht4ލçš²µ…ÞÝ{.©Ãö¾™W€—x$cXèJT;¸—hüððt¸’6™ì†u,ŠÂ.eÛ2bc-ÊžÁ1—,©ÐücNf~À™U»¬ßŒ¦Y'''í½Tr&$éóù¼I0$ïìì4‰Œù, ?Á:ÓG€7à'™yee¥ýÛ<ÙñGdÈ¡IÚ™ö\Ôd0´õàY"8ÖPî+WWWm•ÌNÁ›7oê¯þÕ¿ÚI@¿ººj¶E„a45Gç¯ü•¿R?úÑê›o¾©ËËËÆ®;¥˜­y||¬‹‹‹Vó= ííí¶Î3B‰ñ]}ž «õÃþ°~ó7³®®®Ú0p´¹™¼‡öÿe6#™Zõp4dR“gø¾Í!ÁZ¾gÃsÚít1ûúm6›5¨ÕGØ–x” Ÿã b‘ídŒ¯®®:ßéõzu||ÜÑdÚœ±åt”yÐ’ñM/YU?iq’¦oò@–¡É&™'’3«ª}> à××R&±€kò}šóÀMàà{FÊ’U5vÆ>Ç#Ysïì³Öƒïs—õÓÚÃyÖŽù|Þæu:Ðy_mðÝl«õ—QÎérî6›™š[ Wwr¤å9[U-bä½–5Ð1Ó_9NœsÉãu}Æ;ê~ç”×ìÿªEýsÕØþæ€û“†¤ôÅ<õ>>Ÿ‡œ+9U‹5¦Ýd‡y/ŽBF ̯ŒÔh‹ÈQŽw‚5ãÄòŽ9F"â+öΚ7F’z½û”‘CmñN$lÚÌù‡­ý~GDSoì"2sRßÊ [¹¸¸øN¥ k_Ô‡ÚáLî{~~Þ’¡µ0tÖO:sæ’1HRƒ½³®Ù.Ÿ#Ã"OÍHV–Ødã|†Cެ2×Ù|gpkÚÈçë󻞙ù/àú‡ÿð6¦&µÔ w&Ba® ÒB&x¾¹¹©ýýýöfÜ0¥¹b§$âyd9/¥ÔªÀ%“pyn »YEÆýrÃÄ&:¹|d`“yL@IħÎYx[ijâT×Ô0{7ÒŒªEhVù9Àvss³Ã– 1§óâßô¶×××m3JæÛ¸ï6=D7”5ÃqxHÚQÀ2k5šÞãD^¤ æ\sA?Û ÌÅd2ɼWUµ11‡±„æ:0‚ݤC5ßÍì­9‡•‚µ5æ´ùh¾§ ƒcÌYñÀF‹e©Õ¼Ìy&rÖDÎÎÎ:s²¶Tч´é'ŒãÖÖV“óçââ¢õ¿ñ³þÒ91GõÀ,YOIZïgêŸñ9}<™LZŽ9€‰LÇá9¤#i’ùwïÅɉ4ÐŽ³ªJÌAÒ7")å±òr²\cJ5îïïk2™´yå=HjØssÕüT9(wl¾u>ŸÏ›öúìì¬Ö××Û¸K A¾Í{…µ&/"m{‘m²D‰Ù¨ª'P?™LÚó...Ú=å¯Ö×××õáÇæÜ6`Ì!ñ޹¦nnnêç?ÿyýÅ_üE¾5[Ä óz2ê“шÝÝÝŽæž=ÏlV›ÍfMnwppМ$}’Q¤õõõ:::ªÝÝݶg’˜fd„Í1viLÂèïþÝ¿ûŸ ÏׯÝõ¬™ÿB. ö#“m´6L VU·þ8`Sµ`<2q•FØFèDC:w!øÔ1Úà„ ¹pØÔyÛ]®.»036xÄ~žŸŸwØRm:;;k}–ì:C¨’@2v6NuŠõ«ãêSûšLwÖËNVg4µ>” hL€Ìª.ãéþUÕ©\ÔÙTR¦PUÍù1ljØ" …€+ ‘€œxÌDàñxÜ"€ç2nUÕJzOóÄÜs”Ì$sšLÐAÊ€9L9À€!œœdÀ„íl5æ;GC)ÆÑhÔdX%óoíFþ0÷³ÂF&ÁVU;ᳪZ êjR™ŒäˆÀa@¿ÿýï×ååeM§ÓŽÃ  +lÊp8¬étÚ) ˜N_>f.›·‡‡‡µ»»[U Ùç³-ú ·†1Η——µ¿¿_?üá›Tj<7g̈H'‚Ž[®”yÇ^cëegg§#?;==m' ësÑ‘ÉdÒÊ ®æÊÎÎN4{™DF¯×k€ùáá¡ŽŽŽêõë×uxxØ•óóóúíßþíº¹¹i%Yj»[³JÅÊsÊÚþìT–SÎhÞÖÖV#>ö÷÷[Ä4/kcee¥IA;qßI ?==­ýýýÎéèúŒb¿²•Ïe?²T®¹€PKIãóõy_Ï`þ ¸²~¤FŸ³*ò„ewÔ½µ=¢¾ýöÛNv&k[Ë4É*Í,0ƒÁ joo¯­•ªjãfl1”¾[µ8q˜3_U-‰Ym|,äÎÎN«½$Hí6ûdNmoo×ÙÙYGæ@J£LFš2’=2³ÿööö:§B§ƒ¹½½ÝÆØ¼·¶ÌCö¶×ëÕááa‹ŒZ+UÕ*Õloo7¹ŽïË×ø½ßû½ïHCô»9çûì:ljÂ^ÇËÑ‹ÁëëëurrÒÞÍýT-“ˆ[U¤ÖL0fW3ò(.//ëåË—µ··×"‚«««-ããǰ>f³§¼&NeFD9ŽUÕö£‡‡‡:;;«7oÞ4[{uuÕ¢Œænæ"‰p¸.•̼=iss³F£QËÁÈ“Ù}çää¤9tµ··×Î\¹½½mÄÎÅÅEÇã½È¨²½óúúºÍÅÃÃÃz¾>ßëÌcž’Wêõç¬Ã»¼Ù8è`§Y&aóüžS(}—J6o›€¶3ÐN(¬êÖÆ*cS|žó!iC¢]j¸û ö2ÛFrìbþNlä&f|—ïmSÑ>÷µ €X0} $d_çøìtÑËɸú$Á´Ýæ†IÍy”sXÊþña)“ÐæªêÌ7ßϹ—ŸËrÂö桟ýªšâÀ‰ß I뫪jý“Î_JFrì½Sj‰Ý+çêrÞ€5f¼8‘Ë÷Îùû©÷©ªKç~þ¯@R®ßY~k.5Ùæ$¤×d˜óϧ.‰ˆ"æ|–JÌ¢ Èá@eDðÝ»wUUiFûÁ¡1µ/«Aé÷ü”íI›ö©Ñ¿_u±3žÁ.çS˜»lWæ¦È3ÉuÈÉIkn‰e)Ü,‰è`.9 œžžvÖ˜ûgéZë"ç“(*G-IÙÐlöTZ5 $÷çp¦=3Ö¢Ãún>Ÿ7»åy)ƒ"©ó^žŸã‰¥Ïö¯¯¯7G3žíÉË;dÄÓ½¼ ÔÞÞ^#Ðr¤ÝvY'iÓ–Ÿ›’!ï#:ÃæÇãvì33ÿù_Ïšù/àúçÿüŸwBx†Çǧú»NÊÃ<Ù 0&’Óªì”ûhÀP¦‘ÍðÃÃC§¬%ƒ ”ÑÁÛ€°í€–$uÅž €nooG’ƒuóœ,ï— kVòIͳ{Ù@õ„A•=$]ºR¢`óHfy6[$àííí5#­xÞÓ§R]µ`à±’Æ”C¢ª¦SÕ•dÄRZ‚½M¦ZÒЃ¥êõÕŽ²ì" §b†>¬Z8’OUNò<`IÄ%u¥VÿÂJiÛr¤††WtÄû¬¬¬t4ó€V&’€q¦Üß{’é˜Ò)W-’bÍ­L$H B–vô®" æ¾12¬‡\~n®û=QŸÍf³:<<ì;rrÒæ *Q>o XÖ&æÚ}Ì5¸õ'[ýôÔø§qîìì4[d^\\´r˜UÕ˜QÒB‰ô־¤4ŽÜ¥ªZ{9˜ãÓÓÓ] S‘ùBäg©ë·Þ[ÕÂáÐÇ"oú˜}ñŸ™IQ`‰ñóù|Þ´ÉîaÃôþ~Ž¡T2ÙËF®M ©JSƒu1þYÅÄϽ»MÈÖ‰zÀƒ~J)Ų|¥ª:Z{íñÇ&*rQUù°¬½O*ËüÙ¬½KÎ sØYfÜõ'öÝw1o¾›c¯Íç짪jås.ÇñxÜK‘:k—9«¿ÓaKçŽ_ÿh¿¶ZC’â|Øë£Å)I‘š?UÝR¬)ÉH;Ù}ÀŠsƒÕ¯~–XÌý¬užÎ±÷ȈSÎÎ9Æ:רò…"9œB€Kͱ¹¹¹©ËËËö^Ú ÜommÕîînsöR–k4%6ÚÄñ®ªæ|û Y–5bd)Bó¬j!·K©]Îï»t¬ÍûûûÆ0c‘­7€ß;ZKYõ‡£¯O:¶ÖX,Ûm÷œì÷wÉ«’ƒÂy`ß<Ã;‹LrÌ89æ¼¹- Xµ(ÆàÐ@쾟#_ÈèÌù³³³¶99þrJ8ØI0ˆPJ°e+Çãq›«©à(œžž62+m¹ÛëõZ¾r@A,7™Ò%ÕÜô“„Z€Þy¯^½êH¤ÌÅ´SÏ×çy=3ó_À…MÆ2Yo{{»167775™L:€d¨sYW < ?ªgÎÈ1–iÈ Fê>µ/µìŒ*ƒœWU“]¤|àîî®&“I6ïÞ½k†Z Ã@ÛRS‹¡ªZH‹Ò9Á‚UU‡õÎõ{8˜š•••zùòe 4ÿÀÕÞÞ^DZªÅÈ y(оðŒ›MÙÆ‡ïõžjÕ+5é½D8€XÝápØJ½eõ—ªj•!ôa‚Ÿ,Å— |Tõc²¹¹ù.ÜãããÚÛÛkch›Ã˜j÷Õ?±”Qy.IŽH‘\”RTUcº=[tÀœLI†ÐHiHl8rú>×ÇÉÉIë‘–ƒ ÔÍ…ªjšv§j¡+'­²Œ§Í_þH‚LL¦q½½½mkƒK/16çÀ¸ìü¾¢$O€ËhÞ³Yª–¼xñ¢iá±´$i€®ua^ЏòjµwóVÿeE' Œ}{||ì”Å–¥3 L’yi·è’Ddì9;m½HàÄ^‹RêÓ^o!‹ǵ½½ÝN² 5êææ¦“`|ttÔ©œb¾{wÕn$æéÝ)CéL¢èöö¶­q 4yVÚŠ«««æ|©cF£vp–¹|xxØžGŠ•rcûøøØÈŒ‹‹‹º½½­7oÞ´\¦Ìqâøloo·jF³Ù¬E¶ÙBós0x:M–¬‘³$R‡U "K⤇Ãzýúu}øð¡9mª½Û`0¨·oß¶½H²{&$ßßß×h4j`Ÿ n0´døÖ?Ï×çy=ƒù/àJ™ #™‰U@#ŒQ€ ö'Ëœ,€¢p¹D¢—/_Öt:mv2XË:à T çfˆ¿ª:Ò Æ“ñ­ªÔ´1ŠØ›”çqUÝD8`=ûÞÞ^“Ê`­„«a`ÉßÉð3ôÞCÈ=Ù4Il€ O¿{yyÙBÇÆMŸ{žj1J KLKð¯RN†ù¨¤Ü*ë={WÉ[¤ ú©ZT11ÉlÍç‹ä¶L®tÙõËýý}qÊÆXɪj@#6)‰Ÿ UCà¶ÜûUUû¾çrfiÍ£Í9½}J^¬¥”r¥äˆ®6óK¼/6OYºŒÖ­6x¶ Û„êβuj½ÉqQ–Ìdj W"œ‚õõõ&¡‘Î’•Ãá°¶··ëàà æóy½{÷®UÚ2¿¼/§ÿøø¸Í sëåË—<vúý~}ûí·5êàà ÙFÒ#c=™LZ[3qí°¦80¹î0ïú„E9]¶Á¯^½êì···­$&'ïîî®­v"^‘¢t*3©–Ô.É%ÑR2M€Úzô÷·ß~[ÛÛÛmîõûýzÿþ}[çªÕ 8l‹hG=£ÖD:ùÆÈ£Ñ¨õÉ÷¿ÿýº½½­o¿ý¶ž¯Ï÷zó_À¥´ ‘åòF£Qíîî6-=Ý­Ì|À¨ªÚ†ZU² (‰¡$«ž6õ“““ÆH&HÁ†b¡€ñóóóNU,ËÎÎN}üø±ý,K iäÔ°æÆ ´œŸŸwXL›€û’¶0úSŒ>€kCÇÀ`Ê6r ƾÙD$¼Ù8§Ói‹6¹6m@[˜Û†ÉÌÄÞdkô9à‘÷aÐfcŠ}ä jŸß-³Ò ªªÚ• hB ‡6לɴ¨çÞ™0ˆ-ÏФ‚ù‚ïkáûëXV Éøƒ²ô[®‹ªÅi«€JF€|0™Ïç ìebœ6ˆ\û¾»½½ÝJÞ%ØúVVVZ¥ÑhÔæ¾OÙ ›‘uÀEjÌÑÌ5xÿþ}'w@_rrœIEôU&‹ßßß×û÷ï›”DÙD@ððð°­ýªjÑk³™²š•••:<Õe¬/ì±²DéD÷2¡ ÆD¯­­Õ›7ojoo¯EÕÞ¾}[ƒÁ %¨·ì  ‡_¾€¾Ôá&{(¥H¯ª&AðÙWž-¡ÁÀU-’mŸ*Ç•IºÙ¦|L‡¿9YÞ.q‚?µ}ø¬f M™Àë~>—Zèì7õÀSŸ Ø%m㩪Ž|Á8.‡ûøl¾‹¾\¾lú†ÁO§$YÝåþ×·ÚðfpȲ\²PŸJÌ2O²ªG2ô Öò=c†ÉóNÀ…¶öUÕ‰ dÈåù€GöÑòýsÜ—û}6›uÞ9׊wSén q “y%yøÔÜ(†Ãa§ú†µ’ßÉu“šxmãˆ$_~7s…CBf“’¹” ™'òª…TÜ#eÍŠ`¥óîôNÎh^*÷T-äRîA[®ßûý~çð8ãc®UU[·"0²¼O®MQ6ëÅÜÄ<‹¬åœÁÈ6W=vò£lŸïyý~¿ÆãqÇcbŒü<ÀÓÓÓ=zñâE»§Ïê‹OÙ”\¯ì•µ&Xµb³Ó^ùiŒCõ “mÓNXίOÙ06(íÊÅÅEgßÊ\cd‡­°‚(PJÓ¾å¸ O‰í»»»µµµU¿øÅ/ªjQëe®™ËREÅ2Òe<Ú‰¿ÇÇÇŸÜ㟯Ïëzó_À•‹$<5ÐÂãÚ€hÇ1(XI•²òð¶i/™ ˜F+µ|yP  ¯Z¶aý±UÕ€¢Ÿ9YQâúúº±4‘ï}ï{ œ1šú À÷^¡ÓBÞicc£UÁÐÚ á<*<ã€eÁÄ­¯¯wØ0 hɱ|Œ¥dTÿÏ…csqqÑÆ3ms­!qZ‚سLº«Z$þeâž(…Í[›èim¢ú[hÓ-YÖåæÁCNï’Œž÷2‡1Ÿ r´AÅ €Àiªé0êWcdN*1js¦³%Çre¤yž¿×¶œÇÍáÂ*JºÛÝÝíÔOjA‡ÐšµN9-XZ@&#ÆÕ30ØYIųÖ××ëãÇMBgLØå9ºæÛùùyíïï·ŒUÕæ ý¿9IS ŸÍf-÷DT’Ž>´1t/L1²áç?ÿy³gæ é¡y‹÷{ )ç@¼ù’„­ßÁœÇ¢—Óé´¶··H¿½½­³³³ÚÙÙ©óóóæøÐaÇãV’SÐ3Ø‘ñxÜ*§dôDÛÉÙô©÷É} #ŒdkkkMââó”ds„ƒÏ©àL˜kœ-Ñ9R®Á`QÅ8f[9€.YŠHß`0hïë}VWW[”Çøúèä䤑GöJvAôÈPdly—hÕÊÊJíîîÖüãúÑ~TƒÁ þâ/þ¢þÅ¿ømlØÛÜŸ‘ Ù6s9£Í¹¿¾ÿ¾ªžr">åt=_Ÿ×õ æ¿€ (ZÖ<™´JW)!ÌF—€»(ÙØß yV-j+3fYz±ªZ•@0¢Åô6>O#¬=ÉÔVU ‰Ú dmmm5ö •,ð%ô.<^U-Œm£‚ý2[5’ÙlÖÎêõzm£á8®~4u*ŸœµvìììÔææfÖ|>o›‡rr.ÀÍæ˜e'I“$ñ¦'¬|}}]GGG-dOÛ™ò s$“qÏÏÏ;àÅ}Í%É­æˆ >ÛìgžäªDž€¡T¯j‘sÁYÈdaÏÈwå„,K¯$XbÃ0©6ÓLJòáqIlÞ]ÔPæ¬åÑíÆL_e%)sÐ;??¯ÉdÒ?çóyôªxXÛ¹F€”“`^¤ä 0"I1®Økà¼ê))qcc£E…¬;åR%p[+uðnXî“““æP9Ôs$Šæ4?<“Tëôô´9 æ›ÚôÚøòå˦;&A򯯬ÉdÒÊ(êd>ŒÑhTýþâì¬#‰85îëëë5›íÒ‡Yp¨VÉ+RÆIt‚ïêêjÔoýÖoÕüÁÔh4ªªª_þò—è•~Š'“I³KN5ÇŒ‹ç”$’ävœŒ<Õ[&ýg¯ØÜÜìäbžž¶Zô»2ŽÃá°¾ÿýïGמ‰³„’»DAÚGzþÁ`P_ýu“gq82?E4Œchÿ0f[[[Íé¹¾¾®ãããïkNI¯×«ýýýªªúßùFRlmmÕÞÞ^›/"I9ßg'$p;÷ ÏO §bC[Âò3 ÿ¼¯g0ÿ\É~3€qU7¼Da-Óë·ù&{—¡å /Ó®bì3€uI½»$Ä<ãáó#ÖËš µû¨Yu°¨Z°¿É6UU§Ô!ç»D[Ž%t”vrÀ‰¸iÞÝÙì©bH–qÄT&ÛˆÃøfyȪîá6€2v‡„ØO ýå>6e§IûTÀ8::j¬¾ +÷ªž)2*m¢É­zb‹€Vúaó®=# ¹©2“2—Ôœ»_F$’% Zµ8©À5§†ÃaæŠËئ¤ÆXgþFê¤i©ÍK²¤dK}œ„¦WRmUµšÖU¹ ËßMÖ?NëÓc-™c@hêÙ±ï rÜ—=0ïÙŠÚòù|ÞI\œN§ ªîêõç_#ÎH’5’ŽoÎëp:6"b8ÖÛ·o›žºªêãÇÕë-’¿Çãq+ø‹_ü¢%dbv1Ê’ Í5úóÙlQg^;;švÞÞÞ®ÓÓÓNDÿŠâY³´Þ¤'L×ÖÖj¿~ï÷~¯~ã7~£îïïëíÛ·Mãom!AôŸË¼áüTU‹|°#ª!­­­5M¸¾0×õÃúúâDUQË›››æyÇù|^Óé´c#ØæŒs[gÿ‘_¤¯«y:œ o¾ù¦U‘RîUw¯×kì¿HØt:m{¢±Ñåb³l‡rä­ü›óoê·û·k0Ô¿ÿ÷ÿ¾ÚÚã(p²E%Ü3ÉÌéR×¾ßï×ÑÑQ˰fó”éçëó»žÁür1nXKbYÈÐÓWUKFuÀƒd¥ª{ÈmlÊS2áR’Ù öÕfœÀ§ª:ÆËï°j’Í>¥‰ÔÆ`ñù{› E2¬Éj&€Íª.ŸËþËç'À±Ùx×t:È_”Ò$aÐÝË›mNg$+—,×÷ϪA6†Ü”mÖY?Ýï÷@È1òþæLmmm5&Ò;›ÞѳGÒ Ù¸ãŽý~xxhL£wÂc¶Œ¿Ï§6>“ÍÅKÎ,ð+ÏÿÓÊÊJ+᧯HMH5÷–õþ…½'Ùg™œ@cñú±u¢î'š„ÝNI–õšÂgSBgœÙˆdß3¹Øû[G"& ǘ•a2BgžˆœÐhÇË2·DN€OëDT%8vE$Ízâ@’¤\]]µ„IƒùŸÑvͲÎ9’ ¸Ý[”.í ùŸ«wÜßßoÒ>É™€4B"Ù~ ›Ý¶Æ2ú–k0õÌònÆI_!HvD5òÀ4åxÝ×úË ÀŠ0ÈêLö2%0‘@ÖWÎmì´èÇååe« œ³E¢9¢·¤2úŽóc´vsŸcû9ïö¾/^´Ê6777õóŸÿ¼»þÌH“òÐúºÉdkóŠÓ®J’½d9Zþ|}~×3˜ÿ.fU5ãrmôÏ [•Á µ··×‘¤ábô€"%‡Ãa§¼`³³³ÓÑœƒÆ ™¶`‰vww›¶Sœæ;’>œžž6&Ð%´ ŒcC½&“&ò€½jqÈ’MÓ&’,lŽ‹þòŽªdÐag#@í^¡ªj'üÚÜ@¹ì˜pÎô¹d^‰eÀÏÝÝ]ííí5F°ªš¾Ù¦I¥wvÏ„Y¶3‘2Lä:>>®ápد‡‡‡šN§-dž„ü­úP†ucïºÛŒŽ`벚LØTµp茧ñÊ*#æ* 3›ÍZ_y® *œI,5FÛ•:¬gÕ¢®<6Ô\ ûý~“VTuKÀr浑ƒ‘šÝŒ™Wú=eLÖDêå{½^“Ìä!EUÝ:î™Ï‘¿×ú'ï3›ÍÚÙ ¤t'''Íqù~…"ý¸¼¼lrŒÙlÖï1^ÆT´pUWÄ dTõaG€ûÍÍÍV…É»ÀCã=ŒCF¤3œ£»»§’³'''íÜή1Îd\͘'hLĺPÍååË—ÈžÊ,ý‡‡‡fã1×lƒï‰®­­5-xJÔ¼GWÿ‰zê“óóóúꫯÚÉße²¼ÜƒóŒ‚gäz´w± c¹²²Ò*ž O’Î>4Pýí·ßÖÛ·o[´äöö¶ç<õz½z÷î]M&“&kÒ÷ö„ÌÊHôõõu[ Ï@þó¿žÁüp1.6¡<(õâô‹É6`¦ªj‰=Y¾ ælejŽ„LÜüUŒ@ $r>R+ D<<<´ jãΰ$ÃkC(°…Y«·ªZɳ¬ncÇV-NÌ¥V5š·Q‚ÉøæfvvvV£Ñ¨%¢¥¼Àè÷û­m9®"˜Õ\ÆHÃ@qLèESE/mƒõ²½½Ý“Je^ÅW-œ –eåm\\\40‰3ÏVVVZ…‹LØ­ª¦™µ9k YzvÉ® IDAT ¯ÿ’…Æâ¥Ô©ßï×h4j:a Œû ¸sNaF‘8ÎtïæwÕ«ìþ€DjÒóÔÚÓù|Þ( øl6kIÃU ´ÐØ«ì„aÆô}AV±ºº8|ŒC¥Db–yÄ”zߪŹ2vÞdD‰Xï¾³³ÓÑÈ[~–k…ý ÿ6Ǭ£dl92ž{{[Óé´•í¬ªÚßßor³£££6÷s-r€Í ÷3§æóyc‹­}à h5æ/_¾lùB€*éé›û"Eüÿðð°þÝ¿ûwõæÍ›ö}kDß}üø±NNNêûßÿ~­¬¬4¹[JЪ¥eûý~Ôëׯ«ßªôÃÉ÷ûÙì)¯!£¾ªÖøÃaFè{óÖE–¢ß´{}}½s¦…9"šÃ‰%úðáC˨ªáò>¹8 €?0φZC"¥v;==mkFš5=ŸÏ[iÉ«««–ïd^Ìf³:::jó×sØ8å*3‹¡ç(öûýÎaRöVP¤§*eUÏ×çwõþóy¾~Ý/‹x¹¢‹’|$äjÃað|3Ĉº'€â*Ü3Ÿ›Ò€ðÜÚÚêèg³Éâ1ì¹ç…MÔÞ{þŸ‡ IøËŸ'ƒý™ï‘ý¢2ƒûù¼v.×{`•33Û¿ÜGÙŸÞ+»O=+ÿŸïDåÝs|óò}ãº<—òy¥ž5åEËß·ñè{ /ÿ7?Í-s¬+û<ï£}Ÿ’eåÏ–çßíím‡Î{eß|ê¾9Ç–/ë#s¼‡¾Ëu›W¤ª‹í™Ÿz¯|.ùÑò•ëZW>ãSïi<²¤jV+ñììß9==mÏa‹€7íÎïç,é—WþL[ÜOÿ¹Çååežž¶¶xÿœ7¹>´ÍjJc–ûÌZ°ŽòúÔ¸‡#3ß·n8QY•+íQ:ÔUÕvï”sؽݟÓ‪tZ²OrÞëœOúT¿æú±Ž}ÆšËu—Å èïÓŽZïÙO9n~ϹJ;h Ù©~¿_{{{mÞæ=Òî/í^ž—úéôô´µ3k¾;O!+qy×”zý™s%çVî[®åqy¾>¿«ÿ‡ø‡ïíÛ·õû¿ÿûÿµÛò|ýºþé?ý§M‚²œ<‰=Ä>ÐæaT±œQ¬½¯~²ô™4‹ ÎÍ+’e1±Bëëëð?Î3ªz÷ÔâB¯Ë¥+…¡…ymV™4ÔÊèžžvj%géÇÉdÒ¢ d4F2»Bå ±> M{­ ;–¿j‘øWU«+« ƒN­káþªERoV$ÑŽL^³Ia¬—“ähŠÍ ‘óÂ8›/@87KúQ²…t°<7«Ò˜kØÝœÞ)e˜6ïa.ŠÊ$++ʤf³‹Æv0XÈ3ô·ö#zî”·`‘%ù¥Ž6K·<§ÁˆB`½% cÔs]»w‚æ|^ÕB: ²jk[cÙNkH_¼½½Ýq*Í!ó¨µ KÑ/"bN^ösrrÏ$ÕI;”l»b&cw­míIÝ¿¼ ïWµH†ÏäBr3‰Ô$æ§±OgL°é"M»»»Y'‹0‡DE±­ìÏp8lö[¾€1ßÛÛ«7oÞÔp8l`ظÊo²&ɲ$;+6pwwW5™LÚáOY=̘HªL=¶q˜­ÅÉdÒl,[—úsv—%ˈ­ÈV:"l*»Ïl½yK?n­JHÎ*HÆÈžóâÅ‹V-†s ”NÁÍÍM«Bc¿Ñ>m‡5›LÔ3Œ…Ÿy”9 ˧°÷ûýñÒÇògÒ“Fdýý­¿õ·~%Nx¾~}¯Ÿþô§Ï`þK¸þÑ?úG èeuaM†¸¤2¾,Û°QÙ$€•ÜÐ$³õûý&CIvÖ¦dM-30>›Íp¸”!áÔîîîvôY²’¡ò‡mSÒ5N›áö²žÅý<Ÿ#P` +2ˆ aKÞK§&K±q²‚ æ:m’Œ•ö/K²ªª­EßåxWŽ®õ` ª–6ž%‘7«ðXÛÆc`¾±$ZË9$úæêêª&“I[_æ`Vè1.Þ-绲‘Æýââ¢sÂòh4ê¬vHùËÔ»gBãr«õ‘¥z³âPF2"#£Ñ¨^¿~];;;µ¿¿ßJ‡®®.N@õü«««Þ'“I“kd%'óóÅ‹§K͇µµµ:>>n’D¶…Cäšëä–¤"¤z’{Éóì)ˆ%6Hâ2›gc_=C{Îl6kï16`œ£‹‹‹öY;9£.©öp¶\Ù>ó#”üÙòé”BÁƒÁÓ ¹’Mm®ËL>V(êhŽwvv:ì¢1àX&ð4ï—žL°{gÕŽªúNU"㜕Ţd·ªªµÃ•Ž­¹/jŒ=`æó£ àݘÇãö,IÅ.uã}Çs9sæ{PÐë“ëëëÚÜÜlà0#)Iæ1û#Ä6d”hY*• DŽþ¢Q6/Ò10EÍR]UíQ ßKIHF‡è‘3²•oŒ¿<™œO)Oÿ!²æ}÷ööZd$+8±+À! o¼×ÖÖZ~‚¾ÀBçüñÿ›››F4ÐÔ¸ëëëµ»»[ûûû•çÌÆæôééiç¼ΰõYyŒm><<¬~¿ß9…·ª:ï=™LZŸ‹f~~]}õêUËeåɱTåf¸ÌAÚq`w{{»>|øÐòwŸñs÷ô'+"¥t…}à¸ÑÄk«udNsN+ÐFe-Sæ¤Ì ¶a}}½ŽŽŽycNTUs8ÍMÑ sùC’c¾ÜÞÞ¶ø™z¾>ßëÌÖÍeÓHfºj¾rãat«ªUÏð¹°ôÞ¹y%óÄÈcñ×ùídà0^Éʼ|ù²UQñ]’Œ~UµÍJ{1:$#Øw¬†3CàØn@§D$LuÊ™2¬ìÒ–dï0×)wXNr¥ñtÌ9Ðm“Ãâb©|; ð7䜵ª…4 #•ÌnQÀÊFè]ÌÏ»¼¼ì0­Ëù’J66#,™ßcÙ€âŒe¢'&7K(Ý@.0`#çì“ú/Ë?@dVB²†´É&í÷ú3פ±Æ–[éXs†ógÆ)¥Y&2`~˜—@|Êß¼WÚ‡Œ¨ bNsÈÜ#÷O ¹•ò&QíÔÙ7)sÊkSjæ™úGÝ+®¥vbVSÖd>z/ÀŽÉ$YöÐZÓ/)‘èõz œ/KºrÎY§£Ñ¨“ß‚,¿ëÌW‚>²†N98` ª:Þ<}«MÃA"¡ÂrK6}@¹ªÚg$EÝtˆŒ$¶†ÍÈUÕ)!¨î7YÎÆÆF3f6=`åþþ¾^Ö/ˉ¸++Ou²ONNZÉ·ÝÝÝV;HàTx'À}kk«%ÐÚ WWW[K` ªZb%À̘( &s€BŸO¦Ýfžzl€\ýî#©»ž \Æ á¸a*S×­üš Výé³³³Î/j¯×«³³³6?€è•••¦ëµ eÈ?¥,ji›«@ÛxoúmmnØ@§!H9# ”­ý,;èwœx²1ý¡¿9ÉV†™3Bó ä¥s(.'¥oóžã˜ Æ5~ÆØzH‰›Bâ”ýzww×q s-¹‡ü“d¶ÉÀ²Œ$F6 ãɉã\±žå}E÷ööš\Æ÷­¯ÉdÒ$WHKög6›uæùvO@ûýû÷ûî|útßõ÷p8¬‹‹‹&o²VÍóÙXÐÑ“ÈdÂú‹/j45g_¤$ËVš3š>tdpä-"2ÞCqëb<·ü!‰§ççç-`Ÿ±)`nØ'$¹ŸœœtrÁØû’s0®®®êåË—-¹ªêõë×5› i<×øÃšÍfí3÷÷÷uxxØæg“=›Íf­,ë`ðt*,ûÎy|¾>ÏëÌV'u¥U IPœU0’´iWuk'g¢êÃÃÃC«qœ ¼ï${~~ÞŒ•zww·i-1ÏX :r ˜{/ožÂž60ìÃÃCc¤üƒ˜àÛ´3îØ/@euuµ\¤pz82™S Ý6`Ñýæ,U–‰gUÕÍlšê Ó°N§ÓN’×ÍÍMÛ Ó¹†’ar@ÀèpÂÀÞ¼ 0ªZT ʲ‘ÆK¿{oßÓÿN°5NéÉÚñ©)Õ·)ßʨ”ö¥c±»»ÛÀ†y¼’zÙäéŽZä e(ÙªEI½ÔÖëkŸ9kmÊÁðŠ"d´ƒóMòæ½8 @€Zæ¾§_9É€½~0Yy${’—9â`±ªE®Š±É’TI&Â.øÇ£ï]ô‰~àt™OÖÇF»¼“êQ¬õZõÉ6ô#¹]JçRr†¼`ÏÒñ3žl)GÙ³°ßÚ@çšmÀÕw<(õì<Ô(Ùh}% §~=§óãÇÌà¼`ŠÓa7§Ói“Á‰(nmmÕõõuûF:ÕV·¦­ù0ŸÏë›o¾iI°r€D8Ãk¯×kl7â`6[œ§ÀIæðqF¬c¶`86bÁÏôi²ðÖFÚ0ãål|.›èùÞÉüN<;̲’äø“?ù“úÙÏ~Öˆ4ÑLJ2¡ªE9Yö†oo¯¦Ói[Ï×ç{=ƒù/à’l…U¶9ÚÐRj“ ŠáZwÛ,>e«ª%y%˜I)I&¬UukzÓ°ú]²6ÐÆÁ˜fù.ˆ¶§†ÓýÓHC­©KdL«ª# ©ªï¼¿’`©·Ä¨@Õrß,¿ÓgþŸU@ô¡jä@Iž«½ô—îmOF>?8ø?–ÑæQµ`w“ 7ÙOùÜŒêdN÷uOì¡~Êϧ$àæœ¤ÔÄfhþ›£’Öx¹\ÙN¿Ëþ÷N>ë=s^™Ã̒¢Þ+ßÓ}r¾äÿ1’¾#‘/׎ߧ¼*Ãò}óýÝ7Û‘9÷È(]FVè—蔣dDhÙ†|ªmË?cÃ0ý¿ÊåÏåœg®ÔûçXpú8ÍÙOËÎDÖùN†tmm­1»>—ò ÏãH™_æN¾GÖßO2 û)ßžPµ’ݹw “ÈéK¢È%šfú÷ËùžóÊ8²çççç)–y’yUÕ°òû–$žòžÌŸÚÚÚª­­­z÷î]Û+íyq¸ƒAÇã–äíbsªªUaKÖ?ûÜ…dÉ1í÷ûíä\co^-Ÿý0 šƒ-ªÉ&e»r½?_Ÿßõ æ¿€K#×R†ª8—°cƒÅJ$²ñ ƒ:<<¬ÉdÒXII˜FK F*eUÕÀ}²^¾ÔdfߨÀȺ޳٬LÐê+àÀ˜§ÄH?cú9ÏÁàIâ!±P"ž ¨ÃŽeH_y?‰µ™pº··×þU{ä$ŸÜF’ŸÔ¾Ø*jÐ’'˜³Q*ë—µ™±¬››› l§þßá?™×áwÞðn÷÷ööv;¬ Ø$1ð™LÌLi0œàŠ#›gp:9Ö´¹ž zœ›f–ôÙÙYwÖ³¹FËΩ"?J°%¡Òœ•ÐH¢&Úãþ)å#kJÇ›©ªæL.³¼ÉJ²æ,ûÇ6÷ñt,ô‘wòï›››‡u~~Þ€©i Cž<µíÍoúôÌxxxh…ªžda_}õUû=P,Út||ÜÀ%‡˜ ¯êI¾æ}”´G,W—Ç­¼ó8ÒqRa>Ÿ×·ß~ÛÞ‹ŽŸ-H:ç´„bóS”d6›Õññq³wykïÎ9ÝÝÝm‰ÊXk%„Ùú{ûrźuxâááa}ï{ßkë}oo¯ÙÏííí¶ÇÉ“’"ÏéÇít×­­­:99iŸ—‡2 :óçì쬵ϚV½ c=°ùö+ˆ+÷¨Lr¾>¿ëÌ!·²hÀ$]1í6¥j¡©¥õóÙ¬ÑÌàŒ}UW>ð13FØŽ¬̰[ |«ª1F|9yq9›I’6½ÇFÂI@Õ¢v6pç0  û¥$:fBP…%õ¾ú; ®£Ò}Ž#$ô';\ÕÕs ŒßòFPµÛ¸§“%‰-÷1&™€•õ›³žw&q’!`Ô|Îò “ey1щ‡y,½÷IÉG5󪉺úßóTYSàMÔ4¦Ào&>gâxU5GxÊê%œÌeÎ ó7eÉ‹®J™ØîgúÕ=ݨòoì´9$º¢¯9ù}ÿåÒ6}hÝ`r­ R6ˆƒÍx6y“5è-PŠMÏ„Øt(2×Gd,%=c–9ŸÃ¬Éûûûf[T÷ÑG´ñœ ÑC¶bùÔWcj-Ó¸[¿ƒÁS3ý´ñe¿Fãµ²²Ò@«wçd·Ê5敾ð3‘óùþþ¾9)úÜ|¹½½­³³³ÆXs ±ýWWWÍI7®"ƒÕ3N>; ÚéÞYÚR”'ïuzzÚoï¢ÿg³Eq…åè²@äq>Ÿ7Y&;T§ ±n­ÁÔÇמ•Q`÷åxˆ±cYtÀšbŸÌ}÷àI<=ËϬ£çëó½žÁüpÙ…3|UÂ` ç¦þÑF˜,™;F[ªÚÁ²5ÙêªjL &¯×ëµD>fmm­1www?Cï°4$Œ˜—ªÅ!2XFìwê^sCÃÔÚ{vvÖ6›dµîïïçÄXÒ¤dÕ›šN§ŸÔgbØ´Ù{‰l<<<ÔÉÉIl ´Vl'FÞ&™'_ÒçcE9:˜4 æùùyžž¶ÍߜЗsý@r¡ßª¤a&jë'ïfžnnn¶ÒŒæ¬h€>Jí¶Ä?åærŒ±,Ç™²“\7æ&-6À.™:»…¹±ÅÀ~ÀDstªª¿¹®}Œª®N;sR¬w–§$»€3ùUò¶5gCýÕäwwwÛ\Q²4¥yP[™Ë`‚ž‡‡‡Æ›¿Ö7 9§]ä)°õ¡Ÿ™›î—‘>’²¸ÓÓÓY4Ÿ‘ ÀªwÐ^à6íJ2ÝÕùH}µ5¥ÎÎÎ:š´Q9G666ê?øAÇãÚßßoÀÒI{"FDÈβ•’A j·wÅTïïïWÕ¢¢é!›g>ìííuÀÙËËË&šÍf5N[$L?r„€tci¬|–?›Í#îýÙ9‡z½§œ%óÉÅVx®gŸŸ·äÚL6¦d‘Yǘz ºì¨µvzzZ³Ù¬~ùË_v(sÄ8Óø;…—swttÔl¸ïZiߪª‘RœÕüÝóõù]Ï`þ ¸°”2ïÏÎÎÚ&•ÑÂV30˜<©”´!“¹°Õ´Ú6&›ê2“Ü%£ˆ ¼¸¸¨~¿_ÛÛÛõÁ¼¤,X±i&­Óé´‘ìÒóõù^Ï£û\6ƒÕĬ±-¬ˆÑ===máo†Èf£ÎqÕ¢>± ÀÆ¥4CšŸ¤”ú¾,¿Õï/jòÒEsTVVVêüü¼…HE l®ËåÀì¶TßTUK&¢Ñµ ¨²À!º±Okkk-Ô« ôü üݳ”އç]‚Èê6®Œ6ånnn6Ù 0ªÌ ¤Mž•ÔrDF2Ýd2i÷¤ æœéßBÌ1ý‡™7¯Rþ r¡MùoNÁ2#‹ùLvVi¼ªEÄ#§]œIÑÏɈŒël›£Bå{{{íþ™Ã¸Yé'%!Yõ$Á»9†ÔF3Gðà>>î°÷Iʘ³©"já³»À- IDATg”ŠãÈvÉÁ2—TÐálËÊdq6xuuµ#y¡[×"6ö‹ápX'''Mµ³³Ó¾;Ÿ?å}°9~†¸ÂƳÁÃá°ETHàô‰ù Ô§“í“““º¼¼¬ápØ÷ÁÁA[æ öžÓ'úgüìÇ~w}}]ãñ¸ÙdÄ‹¹ŸrÉçëó¾žã._Àµ,ß`Ìý<«½0P@E†%t  øL–«ªNnÀÜfjƒp¿dÔ–Ë3fåªEø8ÿÔ»z÷LF• B»õA¾w¶Mû€¢Lâ]¾2‰+û.5U  ’÷Q£8J]<‡Áç2œãò©Ÿåßú=Ç.YíåÚÊËÇž1¿êyËó0Îöúž{æ¼YžgÙ÷é&‹»Ü}˜€Å¬‚”ŒZ¾wÖév‘`ø¾sùù9·sÝ,ƒ"ï—ëo¹SÒÄ©HÀŠeÔwYUÉå=–ŠóʱÎwÉu›ŸÍßeÅå~üÔ/ß×ÿ///[ä%û#ï“¶h¹­ùËó?ÛågÉwùUïm]äûä:YžþzzÚI¼Ï>áLe"è`0h·lOÚñ”‹øY®Uó;m“ç~êü‰œ§Úá3Ë×r9Vc•Ž¢öfÿd¿­¯¯·ƒ¼–Ç1?Phaùž®\;ËûŸ_\\´jWÆ!ûD»Iý©ª‘”vÝÜtˆÖòü5ßôSÚ{ý·l3Óé÷ÝóÙlÖúñòò²õùóõù^ý?üÃ?ü{oß¾­ßÿýßÿ¯Ý–çë¿ÐõOþÉ?é$Ž=>>¶°vÕBî@æ!3›Oéô;É’ªƒdÉÆdÛsòÏ'±W`ÄÈH²µh@n³ªª¤,S!a,5¯—„ÃeIO‚,´6`—±*Y×ܳ…¬É†JÚôdùs³LC®·¶¶Z3ûððЩbÃ!FM®a ÒYɰ8°œ²ÏÇbbµ_ÉǬ(SUmsô»íííïèBˆK Åôbš0á˜B!}Úû|¯`$eÆÜ|ÍèTÊD›lìúM{ó¢d`Þ[¢¹ פ£Œ…ua÷mè¤YË ÍÚ#™Uãíùòô?FJJcNc$3Z‡‰Î„Ñ^ïé ¢LÇT’Q˜Þ[Ôƒ“‘‚\+æP–g%»â ßÜÜ4YŠñÑ? vŒ;ùŠq–x-á6×Ár´ò]ò+cíݳ²©™˜9•¶,GÉ0»žÏ>Õþþ~­®®ÖïüÎïÔÎÎNK:í÷ûmosìÅ‹­Èj666j<׿æfÕh4j}ÇÈÄí\[[«ŸýìgM ÎÖŠÎY7j¼Sù%¹F±àu||ÜìŸÒ•J1N&“º¸¸¨“““–WEŠC[Ϧ”RžPJ”ÈÅÈZŽŽŽÚšH‡¼ßï·qªZ丰 ž'ªBû˜"2¡Ÿ¬êúúº9pös,ç†{è+ãaM‰x§M"ÅTUHD$£ˆ?ùÉOþ3háùúu¼~úÓŸ>Ël¾„KòN2<6ß<=“¢r3ªSBMøT¨¨ªª®3Ĩ®Ÿ7 Hæã½„`ÙåJ@Jê ]Y;>CÖÊ„iPÙS:wl›6k‡šÉ4­ãñ¸Ar¤ªjúFNJ2g (l'''5Zà•c“EU÷èv`Ò&q&šŒÇšã°jžN§-ò¢ý˲$†d¼°K™4˜úhÏ$Í‹Œ TU'4OÏ«ïS¢cnÙð3±T„BNÀýý}“‰åÜçÙôó šL*VÅ¢jQ‘ÌȳV€}´gU–Ôb/3ÃúHò]e¿7þÞ“£ <è+÷R"±×ë5¿~poN@FØmÕ^ãç äšÄDsRDÀÑwé¥noŽWêâÙ<ãeœ´Iwy79† ¼ªÒ­|&çŸI©Oó|6›µ¼ŸÌu!]aO­1å,wvvšÃIÃÍ‘4ïSs•cà]^^ÖÛ·okoo¯­õ»»»Æ&;À(Ë~:-ÛÜ8::ê¬=öÅ{¦t$çŒçX׃Á ô}qqѤbÊØÎf³ÚßßoëÀ\Î9TU"È {ÆãqM&“º¼¼ìÈÞ”¯LI¥w Çä({Îùùy}õÕWMî"ÇÌšz||¬?6ànLØ&ý1Û÷»,:¡½< Üe9Y[[[ù‘ƒ¯vvvj<×t:íØƒçëó¼žÁüpex”áj²Mq°‰‡æª'@CWš‰§§§™ Í@ªê¢ê #Í(×U BˆÑ›„zô²Á`Ð6§‡‡‡¦±ÅÈc0Ïyâáããc ‡Ã\RC[µ¨¯ßz½^Ó£ ÍêíYYY©ñxÜ6°ª§çä䤳!©1 DØ€ûý~}øð¡ÖÖÖÚ'6Àšs(èN’ñw€g3I7í]1wjJc¸ª·ñ¶á:Ç¡]À˜äBÒ…ççç ÀUUMU‹MÏ$ßÁüMç ;糜N'‡°yýúu›ŸÀ }*¶Ð˜œ%Í¥e}{2ýœÀd—ýÎÜö´xÄD{‡Èx¦ƒ±ì$O VN¨vV=%ybSÓÏyÀ"æ}­Çd;Íà æ˜$жõ6ª ãÙó'ónŒ…èBÎ÷tô3¢…í7ÆœÆtö€ð<ÔÈÏ3êaLWÁ™bsL5çP´áöö¶Õ÷ ã)x6›µƒÐÎÏÏk¿öööꫯ¾j‡¦!ZF£QsôÏÎÎ:N-§Ø¿ñxÜóéÅ‹õÕW_µ¹¹»»[———­tå|>¯¯¿þºa2ïÖ)9›ÍšÝEJÙ §{,ÀFÏf³V­K¿œœ´ P¬RͲ”ÉZ–œ%Šß¿_ëëëí\“´ÝœOó…šL&ͶKN¶þnooëãÇ͹c¿9åîeÌ)óÒgwwwõ›¿ù› 웇ÛÛÛurrR;;;M#ŸN’µ·»»[­AU}' ø|}~×3˜ÿ.l íú”F<‚l¸ ¸’qc¬ö岑~gH¦Õ3É>šÅF0þØ—”‰T-ÆÈcõO¨˜KNéª'p~~Þ€g¯×ëݦnW›²/%Pù™-Wj`ê³6·e¶igg§±2XËÜR¢C. OïîîØNpfnˆPd(ÙØÐ '£ms¶!cw—«Õ?`ÍEç œ›'æ)‘>Èèç/5ûú1Á>ö22Î’ùˆO6\µHF6ÿô@šíàøz®¹]µpr]¤Ó˜R°|÷” -'£öz‹šÕËý˜Òœ|fV:J†0#i’ÿûo.™›úÖûëC ZŸ¥ŒÀx! ÌŒNè ÏÑï)×É?9ÏÍŸ}ÞÏœ0ïôËòZ±Ö8ž£ yet(×å9«Mžå)Ãò9"”Ö¦¶æ¼w20[Jþ„ÈQHy‚íFr°çîERTê3ó9Ç>‹úp æóyíìì´ïøÛ6OE&Œ¿5êâÈÙ'ØTcœIÌÖûòzÓÖ»»»:99iĈšõH2œŒä™"i–ç¡= ÷C¶“#|qqÑS²7R#Q_f¶¼£ßì°=›tìS’Òçëó»žÁüp%]fº.†&i°¢êØãB˜´€@œÊ@ßçfÑëõ:l*y€+Y†4FYG€”!Ë$fˆ:€?KpdS¤9ÅÔ¬¯¯wj¥8J‡)Û˜T-ß\¾á ­ sZU¶Ã%©+k9{5§Ç†!¿@tÛ˜ï/ñ«¨os#Jƒ}ôh}U1Êê#6»•••‚±R4¶Új³ï÷û­ ¨@ÖsÎÃR677èM'(Ï>00aÞÁFÏAqÒ/^ÔÅÅEmoo·“'µ¨Ðg à–Ÿµê‰Å}óæMKl¦Y6ÆQeÒ¡çšÃO%ëÊõJ~3[?e=ÿ”"Îçó&­Óns]x•E5ÎUÕlæããc«ë?›ÍZ.€9‹€ØÝÝ­W¯^µç=<<ÔááaõzOù ÖËååeM§ÓÖF¶Ì¤«Y6Ë|fä¡]ÞMëkëI"x·¹dœÌŽi'`‹¨QåÅ|½¿¿oï“ ]%¦ÕÕÕ:::êØ·¿ô—þRÝßßׇjss³U½òˆžL¶W¹Ç\QB4•óóóšN§MªjÞ8QVUQÖŒ€“ŠUU+é›?O{A’iþˆ ’ý!îÈ3:õ|}ž×3˜ÿ.úo›qJ5RÿÚï÷›æšFL ÒK×¾G6CºÁ°꙼p’ÆTý?ìÝkˆ¥kvöU÷®{íª¾Ïœ£9ƒ°2DFl"Yñedi,É8 Û2Šl“ÏLB NHЗ@ù˜68"r46Ævˆ`,d¤Œ%ENÀF JÌhÒ3êÓ—ª®ª]—®Ë®ª|¨ó[û¿÷9Â䣻녦»«ö~ßç}.ëù¯ÿú¯õŒÃÔÉæ¦êoÌŒQr–gÙ|r °²ó`ïW5Ö¯O'- 3¾ÉŒbƒõ/f|~~¾«5¤¬eZÓÀ\_ëF.O²§$÷3“E–ØEª’`{t}=YosG×›@9YS,÷õõuÏ=sH;ȼËüü|Nråóö÷÷'Êçég Xˆ8Ó7‡‡‡Í¤)eÉqRÆhq@–yhcMŸù·H@2¨„»Ô3WU—šóy÷ јŸŸŸÈYP&ÖÁÌWYbã9??>ýÒ˜%#ìp$ àúúzÂù\[[ë6+‹šL©ÏåaQÇÇÇqv" ·æ¬Ä\À›¬K¿KôSZ 1oYÐw¤Xfí(Û|7àÏ:·†µ/åml ¶Öz¬&ÃN*Q5>lˆ±ÎÒÉØÞÞî„lïµ¾¾^¯^½ê¶‰ÖiûRU}ð–w0G<óüü¶ÎüÜÜ\­¯¯wÉ\k1Û#Ÿ„½"°>ó9œ0Èììl^sϹ yÚ2‡ŠýÃÀg‚*GX·>ìI>—DûöàÁƒ–÷¥¥¥úðÃÛqUŸ“b½?}ú´êåË—-]YYé1ðÜÕÕÕž+/_¾lgøáÇ-Kål9 Æ`{{»ß¤ÉÜLä, {›œkìîz7¯;0ÿž]˜‡d™ªÆ›H~®ªšId\†Õw1¸ŒjV𨚠…ÏÍÍõŸª1ÛžúyÏúsr™l#`–e×ü`ñlmÎj;)ÃHtjÎjÿÏ ST5Ž,諪qb[2£É'HO)ƒ¾Ð~ì– 4ësFÙç.ŸÍ~õN9l„ÚêgÃá°?gÜ„³3Š3=Ï'šs&K ª†„9ôÙ”[`R%}Ù¨2b¡Ý)gŽçááá„Lëýï|gbÞdõ *F® ÏÊ Ú!Â糟DQ’íÿ¬ò}9WŒIŽg:¬)}Ë+7ÿçøæûdRê´£ ¼aÓ>w…l­wM;ãý²]9Ì“ª±³˜ãL¸ÎöaB­ý¹ÌûsIX²¢TÚ1U–ªÆ$;”mN¢!« dûõaίçcyv@öÛA?ž%]9³£ªÛ‰<ã û[òúp8lз¼¼Üy@Y Ååÿ¢¶æ\K¢˜XôüyŽaÚ¬iI'Þwý|špñŒ\o˜õœŸ¾ëþ­Mú$‰|wùOÖE&£›Û™¿Ä¨ªŽèz^ÎÛÝÖ¤¾#úôYäŠwÉö¤ã§}w×»{Ýù÷àRâŽ;==­ÍÍÍžkJC”¡QLc©4‚”Ä7]BÃN(;fã°± žžž6SŽ©÷üi°êž@n&&P*ÆlooO03Uc&Sh_Á¦èyXl÷e¤±£©9¾¼¼ìÐ7cU5£zɉ°¸ÎëëëÚØØè>&lĘ^}Ló¯¤ûFãÓzmd7êúúz5ˆ£§ÕÿœÚL}(¬Âù¤MUÕò§ŽbÀ„Ïß™™™ IÔöövíîî6»†!v<6¶qÅHšçXfŒ9–€³Ù~ã§¿ñÿ{mý«x}ùørUUçQT6kƒœw‘‘ @=+ºH°¬ªfßÕˆ'õè8T˜lƒ|7ŸÔ>cÖÍÿµµµŽ.çiQ–d«IÛ’9v¿¬Þ”ïa-‹¨yo2= ,+]iŸHe&.[ãúÂ;fqápØUª”¾´V€Ü¹¹¹¶Ï@wºtÆr¦ƒ¿ººÚ•±Dø8¥½Ãá°ÇL¿uÙbejõ {Lž²ò÷­ª&iDLÈïÈJØdJ/­ùŒ¢${ÏùIplÎ]]]ÕÞÞ^ÍÎÎÖÎÎNWgc#¾ýío׿æfÿþÕ«Wõøñã ªªj{{{"‘šƒ#‚ÈvÊÅñYQ(£9)[ÍèôÛ·o;úl/^XXè}=_ZZªW¯^õ^ÆÙº»ÞÝëÌ¿Wž¬gáÓ?ïììL0qä ÂÔ©MÅ¢0’N%ÎÏÏ7èb 1`$˜#Çlçóè¤///;ÈÿSã-|Íàè“9Ú¢$¢M3Ù3!`òÑ£G leN†Æ¦ÅëG›PIº˜zöééiË)ô9㽿¿_+++µ¼¼Ü•*RÓ¼±±1Ánf‚–¶Ùœ19’ x¸RBäß6T?W¯ª>5w$s@îm#â dUz`—p´¨*“d}Î<F20µ1ËjK6å?ü7þp;žæ°Å1|FTxÍúò6w÷®8mÖ…õÀy3S‚0ÉàÄš?Yc~mm­A²ÿôßý§ÝgúR[³âK&‚(ùÞ=Krz§{÷îÕ›7o&òaªªmPŸ”YG©•OÀëMö§ª&ÊÁƒ”Ê,//·ôð6'ÓY7¦ƒÁ ÇÐ\7–ÖIÚHŒ,§B›ÖŒÚUŠs¹R?Îf9sãíÛ·1Rë>í«È#¹9G‰d Ãn§4ŽÓO²3??߉ó)/[\\œ8ñ5í@Í1bsŽëââ¢=zÔÕ»€ÏÃÃÃF½lnnÖ·¿ýí&KÒáÏ÷!‡›››ë¾üøqïæÅõõ¸bSÕ¸<- ë3Ö ç…Mq/2£ŒÞ°[*ëxo§_³·)MT’4óy2úLŽˆÔÆ•‘ÎÏÏû€=ù79?«ª£+Úvqqq'³yǯ;0ÿ\ŸÍxjÇfcã1ØváJY÷@V Û°aÀ²ª‹0(ÍíÉÉI½zõªªª i…§‹”ŒäR1hعããã–ÞTëP§‘¬'…¥´%YFl5€”% 3qX¿ÙäÈ9...j¿Á‹¶è#Ìgm–[[[½A,"€@˜%Þ“c6‰˜×DzeICàbggg"j’ápr#÷ÂÌN€ˆuÛÞÞîÏÒ@„q][[ë>IfŠÓ¬Ñß'xüÉdâ>|عò·éù]²dBôœ/sŸ³ÁÙ@=Ë÷0º)‹ñ>KKK­9–à†ÉÅ":¤™³‘2¬ªj©K¾£þHgÀ|á¬yΟùËa8;;ëaëšcbnçúÐÜJçQ…#KšUnÒÁË Bæ0Æ^TU³î4â×××Íþrö½ÏÒÒR@ë pºººª­­­~GãbþY'YÈœÊ=õ/ðnÍ*çšR<Ò% _Ds0ttõñãÇussÓ‰½Óvã‹t`C{9¢&Þ‹É$ý·oßÖp8ìg™çoÞ¼i‡BtÖõÅ/~±VWWkoo¯ç>ÙÙÎÎÎDDGÿp„€æÓÓÓzòäI´Ý¾wo|‚xÊo>üðLJŠé£Ñí9'õòå˪ª‰C¤ŽŽŽ:‡É<Òf{] ¨Íå3———Û1ˆn}W’¦Œr: Nõšƒƒƒ–û‰Ü"Rìo³´3WWWuxxØ÷‘Ðììmw×»yÍþË?rwý«~¥#f£988èðhžšÈ€­¬¬L¬dÃcLÒ Ð&&Nm³ðŸû¨D#yNh:AT†ãÔd×¼“²w6ïàþÚ)<™@¬j|P&ÃØi²dÃlꪜ*6dZðL¾Í1ÉÊ鬸®,ÇÁ¥o–––&J¦œ!Yd÷^w/²†dAÝ'%Uc¦J"–Ÿ®Æ#—‘›”#%¸Mcú=ç%û½j²´dIóÒ¦Ÿ_Ü`™O~çpæÎÏÏû€Ñ­Œ 䨥“Xêk¿SÞòòòrhÚxps6#HÆà5n™ài½ú;ïeý©ÖQ5Ή 9›f¯½[²´Ö]Fà2"cÜ8Xæ<…Z%šcfæÚ5.þX?æ_–»þ›hÒ÷[+Àq²ñÀT®[mÍdãéü#íöÇýD%!ú9Y_vÔpøÞÑÑÑDž0'©[t3í>Pg~ˆbaôÝSžE®Õª[€-:˜¿—@*ªñÑGÕ÷}ß÷ÕúC¨?~ÜÉõH™£££N µ~ýÞ<,Äš[’o9ëúD¤ÉÙ%Þóúúº÷0Ž‚‚½Ì=­j|Fy—¬¼wO»–¬>ûe/Ìûg~”ˆš¹šÑ¿ÍÍÍvÈ”1NÂÉp_ý4 ZOŸkG-ÿœ“w×»wÝ1óïÁeÁWë “Ûd¢ýý¼ÃŒlð™<&d—5¢†2777QiÄe“ÄÄ:d† LUXHæ 3GªB×¹¿¿ßLMÜç1t°Y·š¶›Â“R${“ɧœï^5f`œ˜N‹ÍÔ»çççõøñã‰MØ,2i‰<ÊE¢“mà\蟌ȱ€‹¨ÀéééDõ •%$©fb- ‚Í|sss¢l(P¿¼¼\/_¾ìwWŠQ(Û™àʼã¬aЀnjðä=Œ¹LFNR®¡¼ÀEò‘ÀDŒÇXš÷«««]eË0ÇlþôÞ€øýû÷'d ì1ðÉvêÿéÊ7@[2áÀ`F6b ÌÏÏwx¨RævïÞ½f¯½ÁììlPC¾tssÓy.333uppÐj`Þﲌ£ufX£˜qý ¨§3L“ÎnÊ€ít Ù‰œ$ U·Ñ e§“m®fäS Œ«B“•†ºä'û9ÝVHÉuaommµý^Óa‡½Œ)À¼´´ÔÕNNN:§Æ˜¯®®ÖÎÎNžžÖÑÑQ'ë_¹F쪪'OžTÕ8*§ý¿øÅúîïþîZXX¨­­­úÖ·¾UÏŸ?ï±]XXèÊb€*"a}}½÷r›,­ª¿Sò‡DI´?ø›}ÜÝÝm`¿¼¼\¯^½ê(ÛÅn'UU¯¶àææ¦öööjss³666Údg¬9—þ9°×$´´´T<˜!’Ž[SÅO‡ÐÙ(¤PævÊTÂÉuqw½{ט.›bÕøà¦¬-œÆ!“ªÆURª&Áb2F6åÔL:E€ Ív‘î¥^°Z¼ÀIÕ˜y³¡'ãÀá8 À§Æ‘ËpiJv²¾µ>Èœ›˜M²j|ð{*K¦¦þ°Åóóóµ··7QªO³ Ç#uÕœ|w²‡ªña7———­e®n¬@”?Oö,å'øÅÅE³ÂÚ­Ž´¹XœœÔ`0h xÐXg‚£p®Á`Ðeè´0Åú‹ºhà—šuáöª±S ,JÉ*gþ‚{¥ŒÆÜ'1H&Ù.É^sî$ž§“Pf0#u"Ã1þÎ0ž^Vš^C)¹J¶+ióÉÒלHàÎXgä„6<SQ€ÃÃÃ4Ê ZK7ÃyÔ&ãî²’™Œ¹ -6 ­Œ @^5.[ ¸Š–庲†Ø5ÎÇgmm­í°9n~lnnöe“ÌŸÕÕÕÚÜÜì2†ÉÆJ9B$Äììø<Ÿ³Nô±y8;;Ûù8l7›Ïþ¨Þ¦Mì:vÿéÓ§5;;ÛµÝ͉ªq΃k—þtr°ñä¤zþùùy½yó¦b{fVCÓ&{Ðææfç ¡’HRú2÷õ»ëÝ»îÀü{p%ÄKóóªqÕ›$à[U͈2Ø òŽ‹‹‹zñâEU«C_©Ü«ªe UãÃQô™™™®*ÀñÀFaå°¨B•Š­Ÿës)K L0æžž¥?~2¬( &éQX3cÛØØèÍe}}½C½™ÄÉ蟟Ÿ×Ç«j¬ß®ª6ô;;; –“¹`fffú`–d?ÓЖdýET¾œˆˆÄØ#}˜ÎÎÎN •r°žîCžÑ›7oÞ4SEþ•9@úêêjíïï×ÕÕU'Üžžžv‚ ™ ; ”¬yn¼)o €È”Z`[3‰0®”ø®’t‘9mŒÓ‘Ãâ[òôuusÕüÈúöœß,Å*òåjèûg—DÁÚ²³¼)©–PNç0Oiç.σàìšsÖBêã9}À=™Ñ ‘±p_ÒrN @dN›c™Ÿ@f!š‡UNûÈNlmmµ ËpÂ$/;ÇÀ÷T #Iä(§$ƒó=6'ÏmÈDÇápضÓÜtÈÑññqGHU²–···Û!JRc¿;biˆ¨v…—ápX¿ýÛ¿]‹‹·5Ò¿ùÍo6iÄ ãL‹ ÑÑ'Q¡õŸ¹‘ëy„ö¥ IDATee¥‡i_U½ÿp9)oâ\&d.XìRÊÏìcH–ÃÃÃÚÙÙ©ª1ˆÏƒŸ.//{-"i䢩É?]éÌx?xð s»*š¿ŽŽºÂÅÅE'ÿZsÞû®4å»}Ýù÷äÂ”¡OÆÅ¦âÿ®dåÒ˜f)¶ü¬Í$ïŸ@„¾Üç§u¿ vÊæ“÷Þ²ÜWRaÕø¨pï–mðo‰ ÑÛ2úàûÚññq3Ä= (YG ¡+!ý™î¼0tÙ÷)—°¹’ _™`9-ò6 ›''Ć@•ÉÌBí)ÝàÄä‚]“´æ³Ž´È  ¡³^³þ uR®S4øÓÓã›ÕURGmÃ5wõ#‡„<=g½oÕ¸Ôh2Ëæ(ç5Ôè§ÃéûÆpZ;íû€´ŸK÷`ÃEº¢_§«qœ§/ M[“ÕÖSÆ”8°fÍH²Ì÷Èqò7Q v–E%[ÒþIíy_—„ïŒúß}\þ8Ð'¢˜ ²§ç˜>Ææºô›{åxäzÒD>|XOŸ>X«Þ=ʵN’#)yÚ‹b!òà§“““®Š£››› L3©–†Ÿ]ZYY©gÏžueN{ âf-±mœ%€@Ö_>—s˜£u}}]~øáÄá{)ÇËhqU5áÂŽ“Øäœàpˆ œœÔññq=yòdbÿáˆé¶Å÷sü]333µ··7q/Ιh‚è@Î_Q}aŒ²4§÷׿ìµq½»ÞÝëÌ¿—Ð>†‡$…–4%UÕaÈL(M †M–1a0éôl® Ìtxžq±áBÓUÕ âè訓WI&R‡î¾‹”6TCéX†>õÁ£Ñ¨Y>¡S'Ú\ˆªêˆÆ Ðð<íNdj¤±P>›¬šM8^\\ì]2´ëûPV(I9P„m“LëßéØÙÔm^6 ò§óóóž3Ž;OF-YïÔmjƒšß ê8[ê 'Ûœgp,0e~ï˜vÏâ H³¡ÓEcª„ã«jBãjþr|IC¬›<=™3:È–Q”TÍÍÍuX?%9XBg@ *[˜ë9æ"d*Ealiï±¢Ö€“’í´®9˜YH1V¤U·º`LüÅÅEÝ¿¿®¯¯[—\UõàÁƒOÉ 2J(1–³fîLWJùX:ò ÎÎÎ:Rÿ’Éd$MTÁ¸k‡ùjý‹äWs(’0`UÛ°Çl@ÚýΨû÷ï×ÊÊJomI§Æ8{†È¦ˆ ›B–qppБ;m~ñâE;rŸØ€õõõŽÌy¦ªFÈ—ª[_Þ¹œÚï´{Nž57ªnúÇ'NžFõòåË>ˆªê¶<®uóúõë–ï`¹}7e'¢)uÓ·{{{õÁô¼y#»Ëè "Â:JâÈz¶çˆ Ȳw°5J®ŽF£®àÃÁxûöm=}útâлëëë®p´±±Q{{{UU=çåLìïï÷šâÌÜ]ïæuæßƒ xæÁ+ˆaQBðúúº°âÂUcKÇg3™f“¯¯¯%ÃÊÈHN’8'7åB¤¢YéPIéËÜÜ\˰B»’I³ÊL²ð¿Î…ä•„L&“ŽÛÆ¡Ž°ðr&™ÎÍÍÕ‹/Ú™êiÚ¨mU“‰þ̈F77“ápXÛÛÛD¥¯2J¡-33·Ç”·³¬(Çi°Á‘é˜lmm5Ð2N¾g3Ë …³‘Ì«SÉd333uxxXËËËu||Ü 5ï‘"p`¨~ÚÔE0ªªó,“ƒAÿ\ˆÝ9œ m43Ãú2ßnnn&ª¸$ï÷†±]\\숄r†ä÷îÝë„\L«5hЉc59Q朹‘9œù³³³®™]U ÀI8®®nKéM³³·I±)Í2?2¹6sÌ%$@–”=??oÔ<¢×öݼVBʪ[ÉhW#Jù%ón|îÃ6j›w6Þn€Z[sîe­þ7oÞôZÏŸÏÍÍÕw}×w5[‹ô0¾Ú©²¼«hgVŸªƒ.â)iÙ=`2Šh<3Õw²hAνt766:ñËŸE Ø¥“““ÚÛÛkYÍÙÙYíïï×`0hÖ;§³›¶Í`¬GQ@`ε9 ’Ìùùy×ÈߨØèä|ÀÞZbo®®®º*‡I!9ÚX\\¬………Ž.è[‘À\bòô¸[÷Óí0¦);›íHÇÝõn^w`þ=¸èÊ«jâ“ÕÕÕf)0³ ÀªÆ:`›a– Ã:$°ÏÍÊÆ’É…yÑñeb+†h^YYiã†qÒ6R ¡^ºù<…±Ï°¥3™5Ï(°œU5qðŽ ƒœ¤†Ô$Ùv¬§wÃK¨»wï^÷?ÖÛûILx96Ø$›dÕøˆq¢¾Ö‡˜ëªq9ß ³Iž„‰³iw SÉBÀSŸÍÏÏ·¶øLÆS4ÄóŒ™ùlÛ„=CtÃ|4wý,omÈÂÑ$˜R3ßK©‹Ëg2“ŸÉ$̪êd>€>¥CÀ ‡+ëwÑ4Ø´vsÎrJ¦¯,™í·½¯{¥öÙæŸ¥³ª ›0§ƒ>ÍùXP‰¼ ò´Øœ›››HõÝiiÔô•Z{kÝqüg'åéä¼Yá+ûœf{sþ§4Ñ<±öH÷÷lÎ)B¸³nù½|Ž1Î蛵`ž)¥ÊާÔÇüÓ?××·Õiôßòòrííí}Ê¡1¾"Cœü,ŽÀ™õ®ëëëMdÒ(‡,çp– ÎqÕ)A ƒ–פ¬45ÏÈ*lªì¤¼¼¼œˆ¶šYÔ¾êsú;Ù$ìÓÑcmðë.OC6ïpöä………ÞC‘Vl6DL“nw×»uÝù÷àʰ4ªB@Ÿ¡Þæ6õéCrjÀß÷háy›&^ø:«XØì°¶©w´ñú~^U½‘Hž=88èw~~¾+<wg%‹:úçôô´YEÉb«¬"`Ã<88è÷xl@6emHD¼³çC(ko£’Ÿ`#Õÿ@On°———]ŽlZV䳋á¤äÃýóôAÌ[Ö÷·É‡O6qø…p‰œœŸO·5/Œ5I 6lº²F&úa°$1fÂõöööD)KýW5–Ãë¬HC†`Lõ§Ä¸Ø0%…å–‹`Žrž€eÀȉ¢©Ù—T˜ †³,™ªÐdŸ$Ûi šfqÌÃ<‰8£’jççç;7HT†Ä‹“kü€w‰”"$Óãcì3)–”ŽD…­Í$föàõë×-±‘¸Ocï°#N!Û£ ¢1í³³³ñÉJi9†ä[ÆîáÇý=}‡i·ŽÉ{8íÇÇÇ]¾7m¿y6 ºí¹‡ÅÆÓÿE_Ø2W:Îì¼²¬«««] !¥«333õ]ßõ]U…Èëì­lvFù®®®Ú9…069•§0ídÞ]ïÞuæßƒ+AC ”eB¢ßUÃéUÕÆ ¸ñzI› Ƴ <Øà”OL|À¯ºÕ\ÒØúÜììm]fW– 2dë¾Ó¥,µ‡žÿææ¦Ÿkc8³³³ .„Ëmémmmuˆ?åY¾0ƒ6‘Ó`¹’õËšòÉÈ^lY¾Ò¦¼¼¼Ü•´ÑæasLgÀ6FYªSýgZôõõõ‡Íö“VÑriúmmm­{Áp¹’‰F¯€\XX¨½½½ÖÈ“?¸29X˜0ýÚ ~¾äQíÉëÞ½{]ÁÂx™k ,³‡÷–ĘyÉLf¿gy?sÀû3ÎCþ^Õ÷ÏgX¿Yš/«U“}?A‡<Ù_ïΪGs¬7`žsK_Ÿ¬úââbKQ*7i‡9ã;4ëÖ‚*HNy㑈­¯¯w[E™> ÐäÏŒýôtÇúÆIÛ)³™Žh·þÍ““­M€Ðs¯®®êÉ“'uqq1Ñy+ss“åó4i6Oâ¹ÈŸõ,Á“^˜_;;;í]\\LØw¼R®´ººÚïxzzZ÷îÝk9ŠŠ:›››5 j86HÏd{ýʆ9ÀØ[Ó'•–H«&VCâЈs0ƒAŸe2??_;;;½¾677{ãg²´5ÏNˆ`,..Öþþ~ƒíµµµ‰Ü•ªÆ'Ö’`{k!…¼9??ïÒ¢£Ñ¨^¼xQ õøñ㪪:88˜(r ¯G›3ÊãžwÌü»}Ýù÷àš.±ˆeɰa2B˜T¬©ï0fXòýýýzüøq—:ó3 Å•,D2€6 _À* )©º}Jpaí¼Fsgg§7~ÏXYYé2ˆYOÚfÎؤ½³>‘àf3ÆØ(R·›,w2ßòÑ ƒžõÙ¨„pÝSøÝ-ümSÀ,‘"é Y– ›®ê“¡xl¶6©gö¢åÜÛÛkÇ`45c™¨È…~ê²ä1˜Ož%¬®¼^æ?pÌ” @¼w–|4v[[[ nátx%ݪ~Ipd‰~¥Ì(tF©4 ÒF ¸lllL€W;;;ý®ÆN´s}}½^¾|YçççU”Ç1êñãÇ5º¨ûËUÚÞÞî3!¾üå/×ââbý³öÏêã?n{gŽ---M¬}¤r4unÅêêjß›DçÞ½{õ{¿÷{ý¸²²ÒÊ™ÓÀ;=¹\óÀaMrWŒ_VÆ™^^^®ápX{{{5??_íÈ¿}û¶ôb—"æ¶›lqss³“ŠÏÏÏëéÓ§=g¯¯¯û]Ù…Ìq°«ÆÑZ¹V¡K)àht[5ÎÁ]ûûûM¤3—¤{È “qÇοÛ׫öž\6HeÌl¾yñô§õÃXžü?ÆŸ~Îô•ÝüÕdéJÿv›õÆÆF3[.†×Eª’@zú³}þž.—²ýŽÍ+7s%SÖ0݆ªqYµ|ÆtÙµéðïôe²Ý.㜟K½ëô%Ñmuuu"G!ßqú½½³Íç³îé=§kûNŽSÊ^Hr¦Ûá>YÒÎ\Ôo;Ÿ12ÿ Ç3û>Çlº6óty¼l¯>š.Iççùù¯¼‡Ÿå33!NŸ@ÑtY½é1öNÚõY}ì÷9o•44~)-Ê C›}“?W>s™ïiìr=¾Ymdzr}¤ÍúýÚésùó”åùÛ{äØåŽg®5‘Ÿ|ïœOŸµŽò³Þ SOvµ¶¶6‘עݢ¥Ùö,_h æšÉy²¹¹YÛÛÛõá‡ÖÇ{~eæñޤ”ù™³³³NœÍµ•NûO[UµçéÓ§íŒeiÓ\·‡‡‡ç(˜#iÃDZ?kOCâd”ÐûeÛr­æÚÒG9¿´1çд}Ö~Ÿç?|V Î,:=wîÝ»7‘f­²¯Îøýì÷Ýõî\wÌü{p%€Îê)©ó®ªfš°>KKK¡ŸH&añ¯®®&Bºîï’œ†íŸÞTI á”M$CšaXÕª&On­½<ÊîóËËË}`G†Àµ+Ù°Ô¹c]°¬¤sssNö® 3Öeww·™µ ò¡" –~8N0òÉðgÒ[U5óÒšd•êiñÞUã$ãÃÃÃ~Çõõõ‰dX!ùŒ>‘ fÍýɹD0Ò"Æóøø¸Ç s+TŸÌ)Æ~4Mܸ0Žúôèè¨åÆ.#Eò¬ïv}}Ýk"Hí=m¸ƒ–Œ a-`Í'TcÐIÒVVVzL½#!úúúº+Ž(¿™Ÿõr™7æäh4êùšrÑ«ùùù#QŒLÚL-²yà9¢"æ¹'ÄB[o¤J~ŸQEö YOÏÙÞÞîÒŠU·Q1ò ßUÁÆ1´Ë\ÍSö/çªhHʹ²Œ"9¡wósóÞ{™‹>lÐûöíÛúè£ÚŽzm ¯ÃÙÖ××»ÊØÍÍMËF²mJéš“"‹yxöìY; Ù:í‘tœsJ¥ó…SF¢bœ@쎵 Äï÷~o=|ø°ë×ý×ë·~ë·ši&‰1ÿÛ7ÎÎÎêàà ×«ýa{{»kßcùE§ë;ßùN---ÕÎÎNº—Φ5!2âÝ_¿~]ƒÁ ...êÛßþvÖg¬IS«nÉ'Ò¥,ñº²²R»»»µ½½Ýs‘$i~~¾m`’q"²¤~öL65“¨=Ï>w½›×˜.ìI2•ÛÛÛ½©g›LD¬ªNü³ ԙĪDŸÍ©j| ¬ ØvÈzr³s ²ŠÉ|1Ž´ÆØñ_\\ÔÆÆF­¬¬´n“Q$ ©º­‰ ø¤“r,Œê<¨ªÛMéõë×­ƒ¥×Ó‰Á£Ñ¨“É*$¸žž¶Þß߯ëëëÞ²ª'©Î¦ ±YµÅ ¬¾ÒÆ(œ“ª±(©$+ú¿Ð·:îäZ67€"Ç «H£^5Þ=37hã’I‘———ý}chSMIŒ’¨NÚ´á“5dbŸÍ1Ù9ó_¿H:Ëcès]ÍÍÝžà˜åD9ª@¸¾³™ “çÙys^äHJRr–¼»þµ>h–ggokÀsbÍ»ªêÏH¾HJ°¸þL6•³‚õˤÇÌ}Y¸¾¾nžù#–6οzØæÄÊÊJíïïw?[$o)Ëàˆp4ÎÎκLª 2¨”ÊÍÏ%\@O:\+++]ʱªÄæøçáL™ƒ”‘ ¥¥¥.eË©áô¨¯Öz–ÖÝÙÙi'µÞ677kkk«û¨jœsb=...vÍró!5í}UÕÇ\ûûû=†Éd{’,ãî¾£Ñhž<|ø°†Ãa%y ¥1¸¾¾þÔL}ôQ.OŸ>­×¯_·Ïk22zuó"ϰfÌMµõÍýãããºÿ~Dœ/ýÇéš®(%/Äú—O´²²RƒÁ B’‚†s•ùZö€´Š­zöìY­®®NH‰Œ 9'Vd„ ©j|†ÉÝõî^w£û\™à–r™iÍijÎód¿Ò€3dyˆ‘ŠBè6tRS­ºMÕ8Ÿ!}›‘ '3ý>¥òŽ.÷Á> Í.lkkk5'¢ XÙ­­­‰Ê)ÏŸ?¯¥¥¥ µ³³Ó:hýÃI¡|à?+È0¶Œ½~Ö$Q‰„0î’mSâàÂ\«„‘eØfffš5Ï*8©»Æ4c¯÷ììloPÂÿUÕU=€¹¹¹f¿$qyÆÌÌ̄Ζ’ùÀ‹±H©”#‘õñ±W"EîOßjÃÏHKÕ-XÉú÷@;Í¿Ä[—3Ãú™`6??ÿ™N­¾5¿² ÀM²@fÖ˜Vô¡9–L¶µn}{¦ûdiFù$)NÉo¸¾¾þLÉ §ñ³¢!éœîýðþæ±qŸmÕÚ’’00>æ1Vvff¦ö÷÷kee¥9ÞíêêªZ«n¨¬€”}ag½~v†ôÞÖ—ùÃÖÉH –}dNr F£QÝ¿¿í/m·û¾|ù²666ú»þÕHgffÚùåÜë/}fΙJõ¾}û¶ú”üx/å+ÍÑÕÕÕÚÝÝíù}uuU[[[=—Ì÷)™Žªq ò™‡‡‡}€•¨@æŒØ“èé9KKKõúõëŽ:êoÏ5^oÞ¼©………Üæ†ê9ÖÛ›7oÚ1'ý!7r–ýÅ÷EÙÆ$ÆÞ¾};qX›¨©ßqtõ ¢(ú—QöÞ>ÌFÞ»w{Ø Sw§¥Žw×»uÝiæßƒKéÀLºÁ:hKn“¢MÀÃHV™b›Âp8lfZH¬¦#iCÄhÙì|Ɔ®íKKKõù7zS´ùx'Ïóû_ý‹¿Úe«Æ•›¹‡åÕ$O~Ö&l#Tj 0Ïä<ïïéÝ$’Ú´´ŸvS_ùLÕX™•ÍcFÛlüVmæ¸xÌ JÄ…4Ãü2Ìï ÷¸&öú›%q.å Þ)å-ÓɾXdL¨þ›Î ÈRš©{Î}D»Ê «ª‰( PlãÌ’uÖOò”s$װ縻¿¾uHNö…ñŠ­ ¥9v>»°°Ðg-`æõŸKbœ÷аߙ0gD€†ûê/í÷û,ÓšÕBŒ°žÙß™,¯?9ØYb4ë¹³_Ö"Çϸk“?ÖjÊÓÈÛ¦×1°œ¬»¹¯oR‚ãÝÙÍ›æ5fC¼²²ÒºïdñÍýŒ|™ é<Éx–*+¢lÇÇÇ]zé°±±ÑvÆ!Yú–’¨jþ˜Ï*Ù¨&†=µÔœÔ\[§§§uxxX/_¾lYÜ«W¯êìì¬çž¨¤qö}cÈÉË2Ö«ßk·Ê`¤S€9GŸTôè訉+Ñ=rMs:KËfÛŽ?Y¶†ìKÖµ9f>UU·ƒ<-óVr;ŸÄ‘NÄŠößiæßí뎙.¬ªšIw -“(šYã;7" ã” ?ù͵{ø>ººÛÉNUUƒxFmqq±~üþxýÊOýJý±Ÿÿcµ¸¸ØmN úììlýÆ_þú±ðc½¡`Âû Âm‚××× ­vþŒ·ŒrÒHêgï”áßì`Fè_%™<ô&«e`‰®³³³Öw“O%èHÆÒ©¾Xãš²(úUŒçÎÎNp ņê".60Úð”Eè[ D¿g5ããã 6Ôf– gY'ZY@NŠ77”04ßDlRúPUbsÕö£££Ur#Œ'F7ËBŠºLŸt ˆ:ÈŸÙXSºàªÉ‹ÏæÜ$©ð\ìyÉÕÕUGYrnf´Èî¹¼¼í4þªÓè3s¿{U5ˆœ±«YÁËœœ™™iðµ³³SUU=jvú _øB¯AëJS$$K:r$È^ªjBÇÍÑçl y”ˆaUÕîînKp²ª †ÙØ[7¢ "SÈŸµn¦ËN®®®6°ßßߟˆ|‰ºŠZw××·yì1Cd)WZu[æw0ô|¢£ uxxX›››í@íïïOTÞŽIpH"{Ü%¥r(í­Y7ÿÞ½{õùϾÉW*8R’ÖÏìåž‹Ôyøða烥ócï®wóºóïÁ•`6¨ ¬Ë2“ƒ#ü8cgmx)'¡dÐñ”ITUÚ µÛ\ªÆIgÚ0êþO´~õ/þj}å¾ÒÀë»°°P¿ô“¿TüoÿñZ[[k¹ Æ[™R–ªêP>À (+á– WÂÅUÕ`Ã\5Þà’Áv·¶¶šIóÌd»¼ÇÒÒRƒ¾ªjGEÈxmm­ï¯ß¼›>Ì'G€“PUÍpaÂ2ÊA²àì7­úÇÜeë´Ø†±ƒX0›=•Q€Z­tÉÆ 4r|nnnZçý¢cå\ºôçÑÑÑD2£« €ä™kkkÍ`“DÙÚ @ä&«ÎuUµãR5–ed%'û9‹¹ÁåÜ™ƒWWW½ö0õæ¢2{î`0hЀÁåètÆr:áuyy¹vww[>• þÍÍM×w'µc[D¡°³œs`}}½¾ÿû¿¿ƒA=þ¼¾ùÍoÖ›7oºŸJQ) yûöm­¬¬Ôç?ÿùÉ¢_œ&y:YžÓ:8??oùŸñ5G<ƒ=Lœ µö°÷Ö>µO‘ Ñ,㌽===­´Í]]]­‡öäóÕz¸¹¹©ÝÝÝ M¼6+;šºlk›CjÍÍÝžÆKk/™V©É½½½–µÜ»w¯ ˆãããë £¥ö ¶^ÕææfÛø³³³úÖ·¾ÕÒB2:Éù[[[í Ê_rž†õW5>“1pttÔuéõ›7ozŸ»ººêgggÛññ|‘:xL8'ÓúgËô‹3HyªªžóY2ï’‘”G‰xdîƒñµáÑ^WKØÑs.//×ýû÷[ÃlŒÓ±$ËS?snšÂÛ6]íÒ~}KN_“¬¬¬LHN2/ÂÜÓ^zæi)¦O/Ž]Kà¢M———Íúžtc’6ãK$2AÜÕKDF^¼xQÛÛÛµ¶¶ÖåJE0soß¾­ÖÔbÖÍkL´{;°òÿÙÙÙºÿ~÷¯hÈÆÆF÷Óô¸&PÝÜܬ—/_vRã?ÿçÿ¼^¾|Y¿û»¿Ûë!Ëåš{ÆCäIâ~:ÕÉf{¿µµµ:88hùIXØ”¥ý0»•1°NUb¡Ÿ>::j}sJAô9ÉEjì«jbŽׯÆFË?ÒxWsÙÜMÙ†_9W‘”Á`¸=ÀÔ&s3çR? ôúz²ª¹¢\,< ë;õñÇwÉØtØ1ÿ¢tåä~o.¬¯¯7Ð6÷ØyL<›Ý²þ¶¶¶Ú©óÁ ÙßßoyÎææf?[Ô‚£Á^Ø›2gfgg§ B¼|ù²çÀh4ꃾH2³`CÊ-OOOk¿F£Ûˆ(âÂú!5bóÓ!bóî®wóºóïÁ%Ì^5 +»W5®vCöQ5f@HgªnKzÈ·”L¬­­u=xúæò6|ìÆÆÆDe’£££fkœ¤ ÌÝÜÜÔ}í‡ê?ýªªúá¿ûí·œŸŸïi3335 Z?ÍxÒ”V‰gÉLÖµÙo*œŸŸ×p8ìjôÂI|Ç„Kfò"ÐûæÍ›þ½*4£Ñ¨å lfffjkk«$OU5ˆ;::êê/ÎÏ Bñê`çü”„¿Í¯|7à†“dýo4ç"%1d@6p]Õd…˜tB0Õ@08˜Ÿt´™Xmd¢xêôÓ‘IGI{¬òýš}Æ9ÌÄCsR€ïÊå°69 Rµ/ËnmmõÜ¥ý&Àæ©n¡ú~îÇ2nmmÕÞÞ^;§drJçS’öÁüWLùÅùùyëÂWWWëÙ³gõüùó:>>îS13×À{.--µÆ>¯®®üécR¤‚@ciÚ[r´²²Ò¶¬jìøi?YƒïZ§Öç.sfÌ÷1/µË\ 阙™i§ÍN'øÞ½{}Fƒ¨ Göàà sØÓápØŽ"'CÞɧ‡úßùOUÅÒ³6aŽççç'$)ª½ö,..¶ ÿÜç>7áüM'Ê&ñ $¬s:HÔœðzyyÙUhÜ‹Ób>g"ñÒÒødZ 8Yõ<—ÄœS*Rb1GBÿ †Ãa~ œ¬M? ìÑúOßÛÃÃà ŸÍ“%÷`ss³ç3‚ëîzw¯;0ÿž\Ø;eDzú@= êüü¼öööˆ@Ý.fÊFCW™I˜@5¯d4¡ø¬P‚ùÞÞÞ®ªÉ“oNHUõF–¥»€:X2²˜cXàÆ¦”å#Àt0î¬^asËUÌX–ó·ÏÚ %Š¥¾×æ[uëT¥VÙ†„‰~+5ùýÈ0pÚï°Ú6ŽvèÉ“'ý9¡j 9“°´ƒÄÉÁ.bhwww{Îø,žßŸ››ëŠ木R&Ng 8óÐÏgÐ…û¿6‰ôÈä0À³÷Åàæ)‹ ïh4ªápØ æðð°ëm‹²L;eæêדÍ][[k‰„dÊËËËÖócˆ9XUÕ÷` ’ž–>Ðk¿}û¶×°ª3"l¶9æL€‰ 0'''ô¬OìÏíííM€oZñL$¢±Ì ͽE”`cc£ööö:á\”Í5ßRêRu«£léà%£Ñö>ZuëÑá²?ï߿ߑ\Nšè49‹5æ¾@8òI OöCÚÛ·okkk«# öû5ÀoouQA¨ª&*GeW:1æõÝõî^wšù÷àÂFcï°;Œ Pv¨S5A¯ª:¬—‹/åØ}FoºÊ€0òââbŠ‘¿ó,›CmsýÆO£þØÏÿ±úÁŸûÁúÆO£Aœw±k¾x»w–#ôž™ÌÈ`’Œ`.1ó~•ÌM8f˜‰Uû7'‡“å 9&@8Àt¨1=;;;!S:W–Œ`vvv‚ùÆøÆÖXe©½ãü)P:À«M&+pççç'd]’ó0˜”ÌŠ63Ì" ›ZX}ãÖÜZÀvy7•>´Yôweâ J˜´ÌOk31ïp,%âe™BQ/sykkkœbø¬Sïhì|m0Þ¢hÚ—s&Û?77WƒÁ ¥!¾7?{Ú±ùåÙÚ8Ó[777]¹…3ÆåÜmJ0XUýïk¥ü‰©çe˜‹Ö”J5™!Z"2”ù+"Y9×I´2¢Ç‰àÄîUÕóvmm­677[‚iµ¾Žº5>/Ä&±S~§O­¯ËËËN¼Ç†›É”sIJˆ€‹ãåçÆ› ›™™éª4쨹ü{¿÷{õòåËžû©«_]]í¾a[8¼æØììlŸ”ì¹~& è;]*W& ë}d£s,Ý7#$2ö[ösqq±†Ãa·}kk«e­" ©¥¿ººêà ÝϾ{xxØ2,™ç‘=²7ìFJ_ï®wïºcæßƒËÁ(YÎÌá*ÂqU“'VKü aÚT] @là‰ÓÓÓf=„^}ÇglÀÓññq=þ¼Ù'€”áFÍά¬¬Ô/þÛ¿X?ôµê öþÖÔ¯ý̯Õýƒ«ªjæ O @˜¯j|"jÖùNÆo¿...êþýû½©/,Ü:‚qânnnúÐ+wvv¶KEÞ»woâ¤Û¥¥¥‰ ¨ªî'†¿êV6ã^±q¹Gæùóçõøñãºwï^=þ¼¥Yè'¿!Pƒ~Ú¦ž2‡ëëë–^ ˜+2 Q ¬/Û¼É1ÀHi'` =ƒÁ %'.À (ò£í6ÑÔŽj‡+“äT†ÀÞ¿¿™rÎÔúúzíîî¶£&úRU]©{žQ*R º_  ·^DU܇S-QÑ!^äSÞOÔDž4/ëÜ!Í™™™i&T†C ðËm±öôõÙÙY ‡ÃŽ0‰öUÝjÖwww{üŽŽŽXË稺uàTÑn,æææf:Draæ¼å0¦<ªªêÕ«WÑö…“ê[•pÎÎÎz½æwè«×ÖÖZÚuppй€cUuD2£F"*˜ìùùùzôèQmmmµóa-9ñ•°¿¿_ŸûÜçj{{»Ú~´e ƒÚÜܬƒƒƒ~¹Ýh4j`ˆñM;¨êQJ§~Ê͇ªq>'m0ÔÇ\óóó d1Î*9PÅ)6@ÏHËÒÒRíííu$XõRÄ………ÖšçØ=xð`bŽØ£NOO{-‘t¥ÄIdJ¿‘¶pEoaÇÇÇ-s’£RUµ··WƒÁ ö÷÷»õpssS÷ïßo½>ÛÇ)½¸¸˜ˆ+lßɨÊβ[w×»{Ýù÷àÊ3ñ´ªX½BƒkkkÍWUy hÕ8t 4 acµlðUc4¶Ñ=Ðgy;ÀÈ©ªzøðaÕßÿÑ¿_?üw¸¥˜‘?ñ?ÿ‰úÇþןù_ÿÌ„ñ ;áL*€•à’PYYY©µµµzýúõ£ÌXœ”ø]Ö Ï„\Æeee¢çÁÁA'7 µbm¤óóó½ñgøWf8¶,àòò²Ãç´¾ØGì5 ¥ßÕ*Ƕ&Ьw¬Ÿó0² Û=”€ËR¨©¯N jee¥ÙÉëëëÚÝÝmùQF >°„é4¯0Û®ôü¥÷\úd ¨qÆDô»rw´Ô˜Aò………Þ¬åZ`«ÆeÕ¨¾¹¹éÃ~æçç,.,,|ªª”ÚûÖÀh4jØ»øž÷Õ'´ïæKjÿ3bÇfH0ÄÜë#l}Fæ€>Q3D‚9ïýã”Ë™?Ö9 †S|zzÚgóŒ &A»ÿ3üÙv,p+!×÷0”©ÛBõL,¹Ð°~JBgžR§ëëëzùòeß'û/¥ž]n…d1Å¢6U`¤ªšYrÏ”Øx¯”eÝõªIÃïaaïd¬Ü×sIg´äœÈù.B¥ýÆ+Û•}€õ³~Ÿ÷ÈÚé©ÏuqÏßÜÜÔöövJs4ŸËÉÂF¦Úß´ÖdÓ5صÁÿmî©ý(\@6k¾WU¯¼·‹Óìy€ê´4B? ‡Ã¿@xÖ9÷;c?ý¼ªO×mÊñšŽFþ~ßg{¬mªªž‡îçó¢e>oÝäu||Ü’#ζþL‡WÄ…s577Wõ³?{ÛïŸü©ªÚøÔ[T}TûÎ_ù+U5>A9¥%æxÚÄ ìw2ÿÇÎF£ h¬´ßxæžãÊ< `Ô•´©*èx†ûª¸3»ÿªª× ÇÌ;e•)m0÷õ{9ÞÓÚvïLúÕ5³w9´ÐÜM»‘„HÎ56!/ºwíIÉŒ±-æs c¹÷Ý]ïÞuæßƒK‰6—l~€Z˜5uÓt¸dBÀB|þÆ:$ÄÌ/6¶?þ¸,ÓÍÍM ‡ÃzôèQ—Õš›—ÃL‰ -jÖ#N`@–@·ÊHc1dóóó8™É›ÞC”áeŒ1÷t¹ÂÝßßo0iS!= m*À€òsBô333ÍFf¥ÉƒÁ Y³«««>Ñwr%ç8 N£%5¨x~~ÞÚsïéYÊJbÏ|—ófó5Ž˜{Œy´ªš(¹·¶¶VÛÛÛø˜‘Õ0²f»¾ÇZCY) ¾ÔuÎè€èM¸÷ÅšVU³Ð€_~WÓìòÞÞ^]__7é}Ê"(æ¶$ÕgÏžÕ`0¨ËËñ)¥$"SÚÅñài}:îea½ãht[  åèz?28ìâÆÆF«ËØ///wwR#mY[[«çÏŸO8úñ\»~—~dO†ÃaK?€sŸ4h~~¾öööêêêª|8Qiìøø¸Ç´‰ uj/m~Õ˜aª…ØÓ¡©3~´ÑUÕr² }ŠÑºè?GïcCÔ·ÇÇÇúb}Êa³@X&ì']o–.¼ÿ~Ger椈àØìd¼Œ¥ dee¥Ö××'Úi>f„Æ«\›>Îrz€¥05Í®{a¥iͽWU5ž?~<Á’Ò¿z'ç)¤,,“ÕÎÜ!o:iýC–dY›´¾€¢SœÑ‰éÚ÷ô×µªjÝ2Ç™óê]€dѶÑhÔ ò°¬p¤½úÙ\`€Ñ¢L]ZZjÐøgô uv #5L#gŠ$кਗò'8×dGUÕ¸±´Òæ¹u—ú}cÉ6°qæMFRJè=ôíÕÕUý·Ÿ”ŽüÄèÔ?ú¨/ùËõ¹Ï}®5Ò÷¢¢Ëüü¸fùêêjíïï·Æ[ßI€¯ªú?÷çšÙ¥WÿãoT^ÿâ§~ª\ýào6H.f ŠÄûÖLnÇK>5îòÒ?´îæ?‰ ?ÝJ ×××›xHeUµÍ›­ÓÓÓŽ”f¶9‡Ø@hÖÆÆF ƒîKáúúz¯'°fggkww·%-ž‹‹‹N²ª‘HÚ8ÝÊõTí¹ÿþÄÞªéô3:ëß‹ úûþÁ?XUU¿ù›¿ÙmÌÜ·»ëݼîÀü{paör16,–‰Q«ª“ð›•Ð$–Ó™e±6öd¾ýœ·± ¾Ÿí´±ÒÛ°€íÄzlll4øIÍ4Öã—²Ž“Ì,°aã •’*ÙDéÔTú(7À•ã‘•Dt:f%ÕT.Àº û&@LP“¥FEDD´a4ךÏ:›§Íªªš­Ä:¹l¾6s›¾¾Ä´sx8 ö3I/õÊÓ’zÜ`6E‘ ¿8ØR5vâ8?Þ#~×ïÆÓ÷¬À Oë´¦¼¯up||ܺb¹¹NÈÉz¦6›#Ö†v0ô;ŠXûrg”z<::ê>\YYi9‚è À¨ï<[»X7¶ ekÿO3VÞï2IU_êGQºî<ðÍú7¯´CU&ãe}éSë†SÊqì¦D†}ôÍoc'’§„áÕÕUý÷OžôúøêóŸÿ|ÍÍÍÕÙÚª‡NDÆØbkCb'™K‚o¤‚\‚ÌßÐoÏþÒ_êïÿk_ûZ}÷Ïÿ|UUý¿?ó3ývfûââ¢ö‚ ñ6Ë{æ<ͨ¨9‚1戥ӕ2&Ž›1K¹£ûç!ˆl‡5.˜ÉÀY67ešì)›ÄnY×)­Âx³3<˜°méÐ蛌>YKëæúúºËGsö}6¥`ÈŠ7oÞÔååe=~ü¸mòÀÁ‰Ÿ%Q»»ÞëÌ¿—ñlˆ6€ »cã«Ær’¥¥¥‰„תqcƒd$mB~îgãÆ`ÏT^Ø“¥½ººªÝÝÝfàÇ,aç^z†“֛Υ°è¤HÉÐaQ•*Ã:’;ÌÎÎö!(Yj1Ð4Øÿøã›U—èµ³³S õøñãÞ8ªn+÷•¯_¿ž¨È :BÊ=\Y:‘Ó&ñ̆aS¡·ä ¬¬¬ÔÞÞ^mnnN$5¦^Ý{› Nq´Q+}ª 6Ò<¬³Iä*Á¤sÁ¡3O„õm†":EÊúÜÞ/“HiþýãçRÝâòò²677'BéIFŠF£Q½zõª=z4QŠ0èööv;u‡‡‡Ý§Uc•¬ªH `Ÿ‡ØˆBÐÏcìWVV&ÂMÖü›7oªj\‚¶ê©B³µµUUÕ“1òÞ˜ïÔå«UÕÎ5ÇÙÏ€­<ìéõë× °7ÇII@ )ÕLÎ}õêU«ëëq‰Àt¸Èý”dË2òfiÜœ±¶SJÖr½r.æçç'"‘ÿú¶·ªêßÿd=§ÃôôéÓ®ˆÂÙ"«âX’¹™«««ý¥2&ì‡R_‹¼¬­­ÕoÿÙ?ÛÎ÷—þÖßêöýÖOüD;ËÖ<ùšª!IÄžÝ_´ŠC¥/ITÞ¼yÓëÚÞ#QÖzÖßÚxûlÚ½Œ:rØC¶A’<ÎÌÜVæ÷ö¯ªêZîìµCÔH­¬ùÖ}júÍ÷—/_öçH£HØD”•{%»\__¯û÷ï×Û·o[Š´±±1q­µ¨ÚÚ«W¯êW~åWš¹çš/w×»{Ýù÷àÂ@Ù¸l4UãšÀØ+à h´éOULÀDÃ6‘”z`)U°9ßÜÜÔ`0è ßÏÈ ck‚±±ñÚtUPÒ,õïÓµuµ cO‚°¸¸X›››]“8õÚ6x›&W­~lÎt%`JxC‡õI)ƒŽ¬»ÇÉQë#£ŠÍÖÖVƒ ápØà=+JqUcÀ¡/ž?Þ Ž#c3FÝ·œ`HU€{oo¯e%dDÆ Ìg™sœ ÏÔÀœšéî§Þ6@KK«d–Í4læ@éÊÊÊD-v÷ urrR+++-³±q’T‰|ŒF£ ÷¬ëëëÎqê^\\¬û÷ïw„£jìT “[/ÚD»KrƒýWêòò²Og­ª.QªO¸c9ÀN¤$¡06rb¼9€q•?àžj^ïíí5ˆÔ6ù+dýÖÖVíîîö››€'ðŽ¡äÜXÚgn¤ìHÎDtí¹K‚8ÊE0HÍüðÉhh 'Sn‚¹(êȩȟÎZJÍ‘oûÛÝ7rT~ë'~¢Çÿ_ÿÚתj,Óa/<7+¦pšØ~¹O")Ö÷ƒúôìëëëÎ_ÑgK,rV6J§Ž“¡]/_¾œ`¿9žœç•••Ö–›7žsïÞ½¶ã———_Ä®ÉER¦ØÜ`k8×$ª[[[½—äì"§Ríyà^~Gläjè§”Žedi{{»fggëÕ«WÁ ¥M¹ÑÝõî^w`þ=¸âªjí·¿mÜ«««Í 3ˆØñš˜ kÕø„V 6º ÿb…S#ŒEÉc®…]îu||ÜàÜﱜɤ%ƒS5aBùY’/ñ¸¾¾®½½½ ¸æô»ª?ž n»ƒK0éØK}‰˲qt™RÖˆF&5Žä÷îÝk°iüƇ¤drà€DމïA‘ Ð9ÀÉJ-}V•I'ÛhC¶ÑиšUã| ýC£}}=®‰®=Y'ÛÎ Å^jK‚VŒ|Ê\sssS Ð8­ôöœ œ¹ ÿšI­)1ØI­8jUc†Qô FéU`&¯Cr²ä¦gKÌûomm5HgDžè÷Ó11áÃÃÃ:99©G5¨P鬉¬ ’?ŒÁÆÆF]__7û©â 6;;ÛëèóéÜs€Ý9>>ž 2jhýr^8™åÔ½›ãlÝ8ûR!¶âââb¢dæ÷ðaUUý{ÏŸ×ÜÜÜDIGÎÁòòr=|ø°¾ô¥/Õ|ÐöD»“Ð`èü1ºÎ…ØÛÛ›%žœœ´3˜IûãK)Úw¾óÚÚÚjF÷7¾úÕÚÜܬïù…_¨ªªßøêW{þ«Ó¯,›Su›osrrÒµä_¼xQƒÁ «ÂT¥ýýý^Ç$r)ë)#L777]R÷ææ¦^¿~]÷îÝ«µµµ–ëTÕDMw‰åö‘‚µµµv2§Ëôª0å{KKK} Þ|P/^¼h§.÷†û÷ï÷~ ”³ÅY¡&‚³¿œœœ4óäÉ“OU7c×8øÖ¢DäýýýõìšCÖ7 a IDAT²RÙÝõî^w£û\ ¬òÊRh€YbTó>ØÓéz™ˆ1Íïå•Òå)!©—ò¢žÍt€C²ñ@&žQõùÔÖÒ¦“od?]\Œ®É$·Ôûû'€,hc&1¡CÖ¡acc\Rþ“ÚëdSF}¾´4>uÕ¦:-Í™ž+Ú^URžÜ”¦O&0š 6¤¬ånÓÍAý”(æææ&*(ùÌl›÷Õô¸>—šôü^†èӱ̾¶éc2õWŽùí3Y•Ã{eò­Ÿsš3imnn®ó²=ÖŠ{¤nX.×ZUuô*Ë=f•˜›››‰õ;=?°®Ö¾w Á0b“åǤSõÏäóååå–p`ÛÙI‚ÖÈôüµ~µ!õÚ*óp¬ÍÍÍOUNI[8??ßò¤”HŠTUÛ€Ì)!-;??ïjBØsìp~×÷NNNêÿøñ¯ëëëú7ñ«ªêÿúÉŸìö‘ªd_½zõªÜ|×é9”N$[—óÈgœ ¡°ÁññqO”î´VsÜœzî2Íý­­­‰}Qt û"ç2‹C¦oÙ{pVØÉµÇ–qXÝÛz<ŸSU Bô›gV˱U+ ÿcÂvwwô“mpj”öã¨a`cjS0FU·€www·t‘ sbšM–ó K¬ü†Ûw¢SUͨt$!%FõââöU H1lŽBæXbsZ¿c=Ðd´@• s»j\†ŽDGäÀ8kkkÀÉzÏÒ«ËËËíÜXƒ¥âµïq`“àQÒ6çv:½¿ýÛ¿ÝÏåɪL>ljÞÛÛk‡ÊÚ³¶Hqì›æ¯dtΡzïJZUUµ³³S»»»‘(lýÛ·oûઅ……ÚÛÛ«»ëݽîÀü{pe5옓êÒaé:ÄÔAº—䧬ê‘FüÅ‹}ì5à ° ³¦±ÂvøwUµáW5CÌ Úøî߿ߠI JÆ8D‰-v€< (Ù GáÍ›7 ÀÒHвÉHIG*å(ú—”èMyAÕøt[ÒšÓÓÓÝØM2ýNëš`NG&¾ë¢+]vÕøàNMøJG®j’ý²ö¹Ôßrêvwwkee¥"çccc£+YÌÌÌLDaªª% y(‹1͹pttT'''uxxX;;;-SÀðnll4ØÆ¾™[ÀYÃÒÒÒ„”¬jì\p<òóUÕ%:ce̳ì_öQ2€æÀg^`ïc!  HFkrîÿ6.äò.²ŒíüüüDÝóçÏŸ÷;ËgX]]­•••ž+ÓcžïàÒVû®y tnnn6 •mar½£µ#¡‘à|åûŠRp¸ÓéM'•Œ¡ªz.pBþ‹OlÖù‰m2Ÿ,ï“uÉŽomc³Ò.:åÖ½ó”nkùù'²Q¢½Úìä]óÉpyy9qr©õô/~ê§êúúºþÀßþÛUUõ»?ýÓµ··7Á¦cÐ\òɸ u||ÜàŸä*ß[ÿ>xð ^¿~]gggíp[ 溽äàà çPUµÔ$e}æ®ùÀ™DY3Hžÿ켨õõõ–ù˜ßÓíw¤8öI„{ªRó2$“ïb}X3'''õìÙ³Þ ¦K½.,,Ôææf—èÍ cw×»wÝù÷àâH>|Xoß¾íŠò¬€ºº˜îÑhÔU*Ü+ƒ.ÎÎΚÕ€¬´ŽÐ3±œœ‹W¯^µŒQaevv¶•R›ÊÁ%ê1z©aLæÈÑÙU·!oŒ‰vUŽ_^^nm*£ž5¿m*Ã`ä(yŸÁ`Ðm²Q0þª$ÌÌÌÔÆÆFv‰ºLÜšmJ6$Zer`HòèÁÁA;<’Ñ€…”Ž`ömrI¿Ærvvv"dÑÖ¦ÎW~„Í+™Ù”𬭭M0Ðé0TU;Skkk533Su||ܵ]óùùùfÙ0ÜÀ`V˜‘ÈŒÑ  Í—£££ÚÙÙ©½½½›®ú½ª&…YYYé¨ ÆQòµö‰\xWàJDHe’?þ¸ÎÎÎêÁƒõ»åB4ö$ Äaã°d¿r$z]eÞÇØÙÙÙé9™e÷ô“vqf9)kyoo¯#=æmŽçÉÃXv}#Ã;Šjq²î9Fuuµç°Í9`Ù2ä ©ý777õ³Ÿ86ÿÁ's $ó’#£M;;;õøñãú¾P?n𸸸XßùÎwš‰…áÜÈuÐ÷ H»ãããŽäqàÈ šöª±æók>"$èØENNNêÿüÓºþÿå©~îçê7ôG{¼ò¶”Âmmm5Áì"'hÃ9:>ì考¬üh–¸+á¹Ú®-¢§U·‘@Ñœ$&†ÃaWÊHÒtá§x#öööú¼{Ð.¢]U’¯TUmk%ÛÛŸÙާ½S©ß¼“mµ‘TÙ#‘_w`þݾîÀü{pMë56l2¢Uc½sUM°] MÕh䆫dœß¹W&饖ÛF¢BÚ@0’ЀIûUãª6~íað³”ú Uãšàî¡í~fÃQ%&ëZO'¯æ;;]qÔ|Wµd0mÐúÒóggg{³!ð{@©ªÀr&0=‹‹‹í˜Ù<3á/eF~?Œ¬TbFPDDKlhÞø±©è/}K*@ÑsFRWí^®<ÈÌý\ÞmºrŒsmøù’ɲ¤ X{~êÕóÊÍØ2g“•ö>$Uãü”ce$Às±oÖ é•(•1FãˆN³œÉ¾çüÏÜc< éÍ>ÔÏÀ[²´´ToÞ¼™XoiƒØšd@(Ë$VU;¿Þ×<&ð}U5>쉭SöSpÔsŒRš§_¬Ÿ]Y©ÿ$$b~ŸuÍõ39i—“uÍ7ýê=Ó6sd¦5è¤UÊòr¶ ›E7T‘zóæMµýJ é]²H€¨æ?ý±«ÕÕÕúÃ_ûZýæþh;Gìþ5žé|Èo0·TµI¶­ªÖÈâÚ—…80)«tBìééi'µ‹ˆŠRâyG'èê¿óóó&h*d©’Q9ÅÖYæ¨?‰xga‰¬Ä”v8kù›ïiK9YIi›ÜÙÙÙžËö½;0ÿn_w`þ=¸¹ª1ˆ µ¾¾^/^¼h6)u— ŽÉ2†Ãaëý¡½·åÑîYA¦jÌð2¢d4@×ÅÅEoö´ÐXÇÔ¯c%±õª¼lll4CãJcæ€u¢1î— mcc£7:EZ^R}pØp’͈€ÚiWŸÑí oc„læ °}Ææ-/ Æ °uªÍ€öÔÆNo“M逃j¿ÇD ]§œÄç”MeG£QkéSåL€ÃÃÉ(ÐÂÂBkvM¨yy¹%TéѤ^__7ãUUýlªùZ%ÃlÝÍ5²°­­­f‡Ãa׉Zööözì8½ò¯út©D¹ô·Æ}ff¦åE¢iþ¸DlÌ9ó9%>³³³]ac8özTVÒ{š“dæäÁÁÁDÞ‹ù*×A%’ Þøs8â" ÀØtä ›Ï¦TU™¿a|i¶U QˆôYCÚ5ãÿú'ì¼±·þgff:¡ñúúº%XõÁÔ÷}ß÷õÜyýúu?7èÍÇ<ÁüèDYTD!•&·Pïvž„¹~rrÒ§f³‘iÏ퇸~à“äØ_ÿ‘é9(¢¥ÍÆ0ó¤èÿ‘õìÙ³:;;«§OŸÖÃOª™œ6kAHQ¶ŠTîÉ“'5ê[ßúV—sˆ çÂÞ°鸉bX“€òüü|Wû¥ñ}‘8d[%JÉθ—($),›ƒ]?<<¬Á`ÐÑ ýyttÔ¤9°¸¸X;;;UuA`^¾|Yw×»{Ýù÷à–«ÆµœieýŸžžvx—·ŸáÖÔî^]]5p÷9 ffì„€%yelƒ *™Úªq’VÕ¸úH¾c™!EF+SU ›¤‡´Ã&ŸáÏååå‡:wR%Õ2!üísÉÆW5¶€­Íkeee"oš5¼ººê(‰ç{î ¨‹ 0Þ6@±DQ!n,‰Œä³ƒƒƒZZº-Ç–u›4ŽÕÙÙÙÃê=!Œ”¶ŽæâÁÁA;dO¾ äWUG8X—46Ñ“““eoß¾­­­­nÛññq³ut«­ÏVTUíîîNÌ?N@À¹ÓÇ)Á2¶Øýö¨éŠ,s`VøœC‰‰OÆ:kSg ää¦ôÁ÷Œö^î ‰LêÕÉSNežnllL84ž‘k$¥)Ñâ¬]__·ýIf8Ë*Õææf³ñ´àlš5ÁvOóœv~úÞyP]®)‰…™ÑhTÿÍ'ºù¿}m.ÊMÊC¶fffêéÓ§}(Ñ÷|Ï÷ôº0Ø3öøìì¬vvvš}fKêã?®óóózòäIíííÕÆÆFÛbÒ1 £Íî!><ÏœO¢ôiss³ž={Ö¶+åI™Ðù¿}å+õoýò/×÷ýëõë?ò#5þ(Å«'ôsdÜ i"ÇDÉKŽ·ó6H@½ƒ5Ÿ¥†Û,Ñ*Ò"ºkýÙ—RBª=èªÛÒ“ÊUrRÕÂgÙ%s=£ƒÈ/öÓޤͰ/^t®Áh4ªƒƒƒÎÕ ¥G–hçÙÙY¯Y¶ÃÜf“2¢yw½{×ì¿ü#w×¿ê— ÇfgcÏÒ’UÕ SC2ábˆ”hô³d€< ¬òoUÕRßül˜J'bTµ=Ë VUƒ»,æóX&ï”ßÅBiS~Ï¿«Æ!í³³³f?òçÙ·ÚžÖ¼×ôxhÇææf­­­ÕÚÚZ¿kºmUÕÏÈßù޾·Qæ%r2}  ïc ´d;Ó1ó3íÊ„?÷S‰C’—ñNùVjKs|Í£Ïë߯ÿ§Û›åî|w~~¾OÝ Ôç²_]îU5Î#à°TÝêo͵l'Åý=Ï;g;ôÏô½3\Ÿscz,a²ðþL©?çççü—s͘îsëÒ}<Ëûp†1îÙÆé~ζä;åø›KYµ…vÛ¼Ëw^ )ѪªN¨ÎqÈ~cûü-ÇÃ|äÿÓOßI;fmø¾wØÞÞ®§OŸvä0Ç;ÇÝXgDN¿bdi±Ù7&¶7Ûå=éèsþלyö;ßS»Œ¹wûßÿÔŸªªªïÿú×ë³®éþ6NúB¼gÚc޲ïùÎï¬è¤ïÍ {ï²åže/œžg¹ï¸¿b®©´ý.ßI[’kJ¿›/l„ûLÏÅ“““®FcÜ=ïðððSk ÷ûÃÃÃOÙÓ»ëÝ»îF÷=¸°2’ÄvÌCV’ɤUÆWèƒ'(á,?‡=t°’ÿ3˜³³·eµ”7IJ`ȱ Z²*Þ…†q0ÔãLj¦ÖÖßîA˜Zm!JlëÎÎ΄4gii©%AªÓª­c=H0‹˜RÌ£wõY’¢”½~ýº«óTÝj>_½z5áäht–9I€œ'Vt}}½uº)wÒþ•••:>>îJ>Oòb#2†Bû Ô0ÂôÝÉïïï·´Á<BÝÁ*¥Ô‹sVUŸJÖ37É2ªn™4à†$¨Ë0=ÓÏ%Ý9§j|Íîîn­­­uùÁÁAƒ0åá2²½½ÝÚå.ú””üjff¦¶¶¶ZÒflÕ¯š¬}^UbŸŸŸŸH0Í I®F]÷÷÷»M âUmJ)•yýìÙ³þüÒÒR=xð ÚIð/̯vxŽÏ§™#%cœBku~~þSÎ"ÉÜÚ9T5G$ÉM) ¦þ³OÚú×?a¼õ3f~~¾“Àõ·<”Ç×£Gê£>j{‹´Nõ©âÒÒRKÑDïRzwppPOž<™pÒiºÉ!û »”Õ°Ù"kj«ÏÏÏ×£Gê{¿÷{k}}½>úè£zõêU}ó›ß¬ƒƒƒ^Kú>£ ¿þ#?Rßÿõ¯×—ÿá?¬ßøêW»OÍ]Õ{†ÃaG.E1³MæÙóçÏksss‚Ý& U²4判xl°5åôÖÃÃöÇÇÇY¬ªÖ˜g;T Úßßo‰iÙììlWsRAÈšÒQ)ëÌþÃöfäλÍÌÌÔ£Gznìîîöü÷l€žmÛØØèÜtQr’ž»ëݽîÀü{p} Êr&EÑŠVUK/°Y€ ƒ–ŒnÕ8ù/¥<$)6RĆUUcyNàŸó‘`y0LlúY-Du›^‚;@¢j\é£j\éÀÏ A"” 4ûÚgÒª1»üøñã–%+®9Tºð2«B¶B¬6Xò¦i°4777QmÈÆã~tüæ0DŽâ}mpsss½Ù`eõýÒÒR딵ÄF›Ì—Lšïywºaó–\"“9i¬õ'V<“ÔŒ¥ê?U5QéE=ìËˡ=×ÚL–K›è¢ýLÙ?ÒÒ¯­­­Þ\·Šæ%'‡ÞÛ©Çò;¦“”­á÷@beoÍÓÞÙ&ÿÑGµ¤%¥'œOó›³b(£Ñ¨ë˜jÀr:·ž™UÑsøÓ!]\\¬•••Î0†N9Õ÷Y:h¬²¿...:©R¹Û,Ÿúÿ±÷®?’žçyçÕUÕ]ÝÕÕÕuèÓôÈ1%Ò”IɲD…’VŠéHi+%Ë ÅâHðçÝ @‹ö£ÿ 1$Ȇ9²d%RDÓö® E¤DÊT,QtèrHöô¡]‡îªî®ªÞ5¿»®÷¥dÄÀ.v=]/0˜™îª÷}Þçp?×}Ý×}?ätPý¨P(èßÞ±I¿uǹæÔXžS©T´¼¼òäUÌŸK—.ÅI¨|„m6›¡qÆv2>$¨²Æ¸?}L¹ÚÑh[zØ‘ÅÅÅ„m¤bŽ DÈòò²666ôž÷¼'rª¶¶¶´½½­ƒƒƒØ7vvv¢’¢rÏh4Ò~åWôÓø‡zßÓOëÿúЇboÉf³ÚÛÛKô}‡móëââbôs‡deÆ’~îv»Qù™ ²$˜ùü´¾<„Šçp‘˺•¦‰ô¼ k™ ´ÓÏJ988 Ïý™cü"[Éçó*•Jzÿû߯““}ûÛߎ½Œ<l02CúÌ“y›Í¦Ö××uzzý2»îÞkæ/ÀÅ‚÷p³¤0 °,èÌ©®ÁFSZ(BÛΦˆ®œu< £”ËåÌ Ìë9Ö=ÍÌÃæ¤a©¨CÅ6m˜Cªä`°ù¾kja8؈þrV±Óé$Ê.{ˆV–Ë›gC÷°~6›ÇŸK®¤„a')˜û{B"c†¡—‰kÎTº([†›Ìœ INR€'´Ûl„$DS­‡÷CÿŒÇ¡)$‹:è†XV†%øR¢Mm:ŽZm$ÆŽŸ£áF—L3%é+O|åÿéå÷ÿ»  ¼¾¾®n·l$,}ÃÚÅ!ʇCÌÆ‹õŒsZ*•tíÚ5mnnªR©hii)ú|iiIoûÛÑGËßl6‡láHÿà©§ô3ôGúð7¾¡¿ø¥_Šäj¢Y8ëDpIÖFËî‘ò3*•JD5݆SÆ8U–{ N•¤˜÷Ø2lßéé©jµZ$œ³gmll$$mN@¸céuttßÅÁáÌ "øZ X—ƒÁ " 8î$ùµÃn±¿AÒu:Ø—¤I¹eþàή»÷šù py• ˜.ÌlÔ2âËÒ0\T `³p)!_À* à9ôE2ßwæŽM&q<xóŠ.c¹G:áÚI× z«ož¼/ŸG&ÄÏ´Í?C?À$Ñ&†ÃalZÅb16ô˜$O!aÂij6›±iÁÈx?ÂÖ:Hây0AÒôØ{¤WüŒöQyÁ+朞NN DXr€À=7>hÍrm'ãíɧô;@HRÔØ–”`oýB[J»`Ì8MØûƒw…IƒÍzüËÇ\¤ý0fÌ?I!#á]<éÒeî18(”[dNÃîñLŸ3€Ì½½½ÄÜôñÅ)G‚A0_|®0FÌûñxR³›÷A²À»0¶Ì1/à‰ÿ{·¿·ƒmO̦>c’Ëå"Iš1èãèÃÆûü'Òãɶ8{0š€R¢T¢òÄ{Ï_à¹ù7D…úqccC+++ñF_Rì„ýá'b §YK0ÉÞ×$íü‹ë0J[x*æôû}=ü…/$ÖÇžz*‘ÄÊ8îé7úû@$ÆIiZÒùŒæÏ>ð=ö­oégÿÓÒ‹ÿ¸r¹\DS°Oθ{‘Ú‚ýÎd2¢:•G§Üabî{IRúÜIgì-äQK"d¼+ö‡½9GÎ vÜ“a‰þ!óYZZŠv2î¾7@œÇc½òÊ+’ò ÖÑqžÅû@˜øU*5‰7»îÎkæ/ÀÅFí&WRxüÆÌårêõz±Qà ””#ŸŸŸ«Ñh„k-M¹'ÔK¢‘Ë>0ôãñôTC7@SŒ/¡Ïl6Ø\uý1½k…ÑfS"m(òˆL&£­­­ø¹¤„6›û {"É GÓ“§aì98 ”ÏçÕh4BvÐn·ƒ…ã}p˜ÐÁ´ècžf6QÇAãK~ý€´FRÌ9˜Wæ w}}=NXN—VõÄýaâaщã¸< Ç€úÚ¼#c ¸ÄŽ {`x G?…ðîQ3lßòò²>ò‘èï|§¾ùÍoê™gžITêaM1ÆÈ²÷ÿîNyYXtìJ¹\Ö»Þõ.mookmm-ˆ ì¬Û/Ö¦;}:;;S¡PP§ÓÑÕÏ~Vëw>ÿ£_ù•ˆžår9ß™k0ø.q²‚±úÎãGiÄ|>¯Ÿý£?ж¼øñëøøXçççul6›a߯_¿Î«~ðƒ¨^¯G©]ò?k¯sssZ[[Ów?ö1½÷¿ü—Xçì/TMâ@>ÖŽ{ò§óóó¨°Eÿ"Y„ƹaÌêõº*•J¢‚“K/oÞ¼'¤ziâ•••8UG—uÀšFʉá’GlÕx677ã=p.°yN!“¡úÎ7ÞR¦^š&LW*&rcØÎÎÎôꫯêðð0=ž]wç5óà‚µ¦Ì†Å²pÃâL:?‡Ápv‡#CÙ=îA 9B’ÜS’nß¾-izz*Ïòòr$ŽF£H쑦št 'ߣ]¾‘²1¸A£mIWc˜sú#Ž íuíæp8 =,€Iš².€׉:Ó; ¨"§€ºÇ^c0].—®ëÇ"l8Qa`Ós­<ÌŽàÃe7lŽ^vŽÌ«þGò©¤ÅüÝétbÌp¢\ƒŒ.›>§®9ï')Ê’¸IûØÄaÕa ‰PB<,Ì#]«&pÈü*•J‘¨¼··—Hˆ¦\—GºVWWc\p ˜Ë¬QžqéÒ¥ÐÿXxå)dqÈ>†ÃIr$Ñ*?šç¼'QÖ9óŒyG$&›¹ PظDlmmM‰¹ÆçVWWCŠãN‘‡‚³‡C€3L”Pð§ßˆ*Ñÿ”_ÝÛÛÓ÷¿ÿ}ݸq#@n:ÒÆø±ú_ô¿ßY?$‚ÏÏÏkqqQkkkºté’¶¶¶BvóJHŽ“FÛ‘^ÐçÛÿá?h[ÒÍúOÃÖ-ŸJ£ÑP¥R g²ÓéèôôTår9@¼'gzôæ¿þÂ/„Ôä]_ú’$é¹~4ÙYZZÒÎÎŽ^yå]»v-$8/¿ü²ÚívôéÁÁ2™i‰Vl¡—x%š÷Ý}LïýÏÿYÏ?ñ„VVVÔÃä(º IDATjµÂÞ‘ƒhöh$$ R- ‚‘ca{Z­V¼¥/aÏ™2ÌMwÎX8éµZ-á(!õƒ0"RÀ=°åTŽqâÃÖyDÎÑÑ‘®\¹Ñ&JL²Ÿ°ô^ÞØÐûÿôOuõÕWUðÁˆdF#ííí©ÓéèöíÛz饗ôÊ+¯DRôÙÙY-Ø0Æäôô4ЏäéÍûîÓûž~ZoÞwŸ$…”̉"ì9ïÆ;Àúãì‘á™DU`ë!Ø p6‘Ý{EôûýDDûÝk·Û g”>ðšüÌ5~OÅ'ú†5t~~®r¹ɹ¬g¢¹€qöÄÝÝÝD. ûytZBNüT«Õ ˆúý¾>ùÉOþíÀÃìú;q=ÿüó3fþ"]^±ð7ié¨oKÐ“Óø†ã%%KJ @¥RyËá5n œíÀKÓ2|°å0¯~´½4aÍÑ0Ò6 ¯”Ã{$x¦,x@¿ÏðZàî°ÀÄð1q-g¯×‹J€JòIôÕô•·6»^™¾ô<¿Ù.K‚­$dî@Å-}æé}Aÿ9«ÖËÃóY˜až¨8 îè–i€Ž¾EF³ h|2Ž®·v-° Ê…¦/€»ŸÑÀÜÈçóºzõª~ê§~*ưèýÈwÒ!wÆ‚wç݈$Ї‰b®ÏÏÏ'À´—?'U}è_tÍ„ôÑõò>8ê’âwÈyÐÞƒŽ'•ú\sà ¸wÖÔ×(}â ÷¬U¿¯Ë¼úû¼åÿŒ±¿/²CÖÜÿvçÝéÃR©¤b±¨Z­õ×}Œ 8­Œs ­7×Ûþà$Ióo&ÀöŽÜrí³çp]éç5¤å=¼d÷Z\\Ô_þ£¤³³3½ûÿXÒ$2ÀØP·Ñh$ªCáØ¤*îéÒˆ Æìç¾úU=÷ÑJš&{zeÚÎü¦­^ö—{sOHÞuëm —ŠõO[Óg]ÐÌ}Æüß+01¿¸dÕ/ò+p^þ¦½~výÝ¿f`þ\°P’¢:ÚÙÙ™ÖÖÖ›à0†Æu°$9ør`Âsa2¥i o˜ a@îh%1ÐC¡½^ï- cŽ”¦@í¢?‡z˼¬3L(ïâl Lúe~ÃI=r6[úLšÂà´PW•aÜØ`ù. a.™J;l€J4Ól6~>€·»V«%¾ø¿;°<€H/UÈ<òü6(BØlÖ°_…B!ÆÊ™ÍL&U„8<–XRBjSÇ82\.…,òqD¼T¹‘”`B/„Ö™KJ¥¢^¯§›7oêøøXív[?üá줇Ç]’@>K$Îa÷úý¾úý~È×XO¬/ÀãééiÌs—@0®'''* ÚÚÚÒÒÒRh…=Ò‚Ðn·H0ï‘u’H°6™×8lh‡yïL&@ ?ë,}r)¬;sÛ“©Yî,¬j,À’ó®ŒïââbÔ\—¤ß^^V%›Õý÷ßÕ]VVV´¹¹©\nZ¡Ë!ù#MNÀ-‹ÁàÒï{úi½þÏÿ¹ŽŽŽ´nóœR”È©`^o4÷ô;ïFÌÙÙYD ½ž:ù8ŒóW’žâ ---é¿÷{zþ‰'޵4=9Ù#g8B$vº”…ßc[ôÜG?ª÷=ýt€èl6«õõuår9íîî&rs–——uï½÷êúõëúÖ·¾ãçÎk6ŸÏGu3ä&䃱¦¹/ÒÖµË,}.4´ðÜï÷uåÊ•Èßyã7b½xò¾}¢skkk‘OÀZö ç;K%l!{`º\çââb8MD+±é|²YiÊ»ûšÉl.ÀõÛ¿ýÛÁšžwžüè M€Ðµ¥n¬¿x©E? éŒ$ œ1@€$rI‰CE4J§Ý$'’@•ËåØÈìäóù’mXÆdÓF펈Ë%2Ífó-L?—4Äé”$rÂ7›MÇf‚nþüü\õz=ÞFˆÓxé—9‘è:779xˆ>Æ1csÆ9bC`1~Ì ¾G5/•ÆÆ‚¬É5ÏÒT2q~~¬· àÏX0Ž€<¤ °Z0ï$TžŸŸ‡Šç#?Z\\Ôƒ>¨~ðƒºtéRÌ]d~Ü:šnizØÖÒÒR$ÚÑl |ö÷÷£o%E‚(²6æ` äåWß~¿ýÃ<¡­ô!ïMû™Ãé¤7—Â---©Z­jqq1סÏ\&å!~æ¿'RƼ9??×êêjD X¬egß‘¸±fù7Nk–5ˆü g°èm`r?Æ…3+)êï#CÒ÷?ÇúÝË—U.—uß}÷éá‡Öµk×´²²¢«W¯& ÊÎ:CïN%këøøXïøâuùÆ ÝþßÐùù¹šÍf8j0OÜ'2q™¶»HÍzœ ´ÕHàÈeøð³Aœi>ôÞõ•¯hãå—õêÕ«¡é&‚Ã{òŽ<Ãó>ÈMÁÙrûú½÷êç¾úUýõåËiu¹ ¹’´¿¿¯ýýýlÑf>ç;}âÏrù!¶°ÓéD®¬¬áÁ^G{™W)dÝýôOÿ´Þõ®wi4ÅÉ«8c êõz¡OLg³Ù(€TÕûÓeZÒ´®}«Õ Îü`=´ÛíÐës_$z.=F‰6}âŸø[¢‡Ùõwázþùç5;ì\Îj`l`Ø}ãô ˜RnÞüÎG¸qcç:sÚhâ;ÔÇ€âdHI) ZGÿ=Î‚ëø¥i8–ç´ÛíDý„vÖY~çÞô+l®¤ØÐad9èw»¤ÄÿÙÃsù}¼n1Œwú}èC/+逄 „ÕûÓuÅ<¿©Vhlúx*˜l¼2w¤\ÂÏ=¥ii*ùðöò‡zÕDý¹\NW®\ÑÃ?¬÷¾÷½zôÑGõÀ2—'Oû=qVÒ'ݲé£EƉa-º\âޝÏÁ!æÝxwÆ0ÈóéK?¼ PëåNi²7l‰^ÔjµDþëpÁØ{2í`Îá Ñ¯Ì "w^©ÉÏBðuÁÿé O"fÜ`eq†xO[@šëü)+ù[wìµã·¶¶%½\¯Ë-ÆãqÌ7N¾v)݃ÿñ?J’öþÕ¿R&“ Çžµä¹ ’Þ"WJKû˜—Rœcò™è3’"ýYi©…×ôÇúƇ?,IzøË_Ž}VÛߓﭬ¬$ÊcŒ8­9]ºX’>üoć,`ÞÐßDoNOO‘BìDz>ùü£½$ãódr®s…ß¹=ùq’ÂÁ` Db*ïÇš"r*M£ST(cb/Aãϸ§ªÂa¤]‰sPÏ\äû€z—¨Í®»ïš1óàúìg?†•*ãñ8Ø58½êÌGºV;Æ ðÇ&I2'Æ]1̘¤Dtœ‚tR'›@ŸÃWØ@¼Ä£kÝ™À(ÂFñ.l®°´°gX=ÿfC¤Ó6˜zÞ&ŒçPÙ‚ ž v–œþ¢ËårH |Ã)rî2'À7К ã"íܰáJŠ÷e³áa³FgïòÏ)¦Zu„a\`§p¼h ‹ÃS3X3´Öš qnn."!ÜÓÛ–––ôÈ#è©§žÒöö¶ªÕª~æg~F/¼ðB‚õç]p؉åó“S\Ûív(O&ù4“Éh{{[¥R)΀ET±q¤©FÝAÇÜÜœÚí¶ªÕjTÒ Ÿ«ÕjÈ@¼" k èå)a*f8T"Bâù(0ÃW¯^ù‚SQ,,¾4uü<ÒÂs¬Mgi äå‹ÃL´'rssS¥RIìíéë<¢«W¯êÚµk‘@Œml6›áÄz¾ svœ¶‹E]ýìg%I?üÄ'Bê€Ó‰}qM8ެp:ñ³V«Å»b‹°«8"‡‡‡ªT*‰r¶ÌÏQbü°¯ß{¯¶_yE?ú‘öxà- D™p!¿BºÆZÎf³:>>Öáá¡NO'eŒ_\]Õ};;úÑúz¬Wdz0ÏŒs£ÑP±XT.— ç€yÁ¸;9Äs)A‰Mâs8ËŒéÙÙ™Úív¢ºX»ÝÛâóŽq"êÀ˜…õÄoÆ`<ÇaMÌoƽ’=gnn."VKKKÚØØˆÄ`˜±7¸S3‚”•*n¬ýÅÅEýò/ÿòÿ8p˜]g®çŸ~æ/Âõ¹Ï}.ÒFw ĸ …0¦l’â÷’UUMü—Ëå#G|yE J b´N†KD`¨ÙÌ\oŒ!§F5 ‘g²Ù9; p¥Þ»¤Øl`lÙ'È …B% 3ïî‰lH œ5u  ƒÉÀtr¬;FœM3Å=a»€0^È\ë ÃIABB%—Ÿà¼Ð'£Ñ(*© ´8VóóóQ¥C4 °¶¼¼¬r¹ïˆÄÊe^nuuUÅbQׯ_×õë×ðèÆÚßßÍÚ“a½Ô)›¨³ÄH–——Ãq JN¡PÐõë×£%%<%%Æž K€{Ö¦GMHÀÄéen¢=öRxÎÆõûý`—ûý¾ŠÅbèÑ]ƒ3å•Cpô‡Ãa”±¬V«*‹Z[[ G…¶#]p6” 0 iÀØ;;©€$†ùÇç\ú‡Í¿}}à´:ã¿´´¤Z­¦B¡ïÁ<ªV«zÛÛÞ¦ãªÿë­jµª………XC®Á潈ƑW Mµâä眜œèòïþ®^úä'5úÀ‚‘w&ÙOœ#5å«JlQœ$/UèÎŽÏÖ2þÏùóóóª¿ãzíÚ5½çk_Só¡‡ù=1G9ÛÛ˜Éd¢t¯kì]Þø×ÛÛúùo~S·î¹'a±™”åþ‡‡‡Q…Œ÷®T*±är¹Ä©ÚØ œCß#°Ó§§§‰Ä|ìɦì]¼'ö‹uDY(ö·T*iuu57Ö3ÄÃp8­Æ'σ½–õŠ}ÃQÄ!f-ŒÇãˆR’÷Å;³VHæ;30w^³j6äêõz¡ƒö'Œ& VÐ[Eví ¹'::k%MB©^é£ ûæ5N~œñu½? ˆö´Z­¨ Èecu @¸’Ä^IÁþt—'Ó§¼#ì<,)ÓK ²¹¹cÆ¡/$‚&Ñ»n +cÜ\&À€Í§]6âålNœ–Éœe.²aJÓª¼Q³³3íîî*›ÍjkkKõz=X´gžyF/¾ø¢Þxãp*qql———C“_­V£‚’4ÙÒô@3JÊÙx÷»ßšU`#Ï“nqV]âЇY#AÕOLöhS.7©žF×™èùùÉá5” ä0-År¹¬z½®µµµ„4e<G"3`¶\.‡cpvv¦×^{Mår9ØÐ´m ZD_RÛžú×årYÒô¤T´íœ5ÁïÈß ]+ϼ æúúäè%æ$Ò."[ô/Äó§ˆ9‹3êì)2Xhª§da‚ïýüçõƒ§žÒé[AAÐBç 0ÇfxÙYwèq€‡Ã¡ªÕªšÍf|.]5inn.Šòñ½|ùr8ÁDh`|±µ/<ù¤~î‹_Ô÷~ñ#Ažy™€ó‘Ïçuß}÷é‘GÑ‹/¾¨[·n%*áà€‘M4ˆ$S¢[Ò°—J%µÛ툰zR«çùìïï«V«ˆå!s E`Õ‘Z1fÌ¢,~î „ÂòòrD!±OÑ.Æ€„X—H‘#²´´óâ†ýÃ¥L.§ƒ ™¹^¯¸gÏpgΓ¥———cŽú>=»î¾kæ/Èõã€<ÀÝÁ&`‚+­••! ËYD)YªƒË½sR2ÌK¥Û @ó’–.çà3g/mˆ„HJ”}„Aò²réçû…£ÁÏ1Œé¶ÿ¸~v) Îæ}Mø†Üç k|ÏõÊlÄi=>R>Ïfã wŒ†ÃaœÆé,4›1ó°Ã†íχ±i1ϼýݸÀ†ûšiïésƒþe|Ýá1¦onÞ¼©¿ú«¿R³ÙT»ÝÖÍ›7£J3Zðsú‹¹ãe)i,=’+Izýõ×ã`$.€ cO%•ôxR‰„ i Î ýEŸçr“Tq@ÉÓ ]™L&X<Æ–~æ3¼#˜Cg1sؾÕÕÕjpxÎï͸r˜—’ä½çççuxx˜ÈÝ@!MOãt¦PÇ{pš'zØÔJ¥rAÎñxùïøâõÚ?ûgÊjZ2‘õæºli* cœø Ž÷üü¼6çw$)ä®ç¦£n<Èß¡êõz´-½6¨ˆÄ¦ › B½rN¾å¾é¶JÒ»ïüä,5ãÃü%Obss3"%E4÷ýøõäÿ±þüƒ à땪Ž) Á~-fÒv–¼Ö£ÛI¿kÛê¥EÄal¤kØ=’F4…ïz®kÚ?—–®BŽôz=ŸŸG$Êñé¥OX£Q8î<—}öϺ»¯˜¿FIš2Xhgù9-e³`„G£Q°}lJžl ËírX~0´ÒTAÞÂ&L8’+’o·ÛÑ-¢KH´øÂ$Iÿýÿcåî¬5J'5$ è¹'î¼ ‡C]¹r%¤y8ô9räaÎææóù˜«äI°º¶¶¦z½®n·À’¹G"SÂn,,,è[=¦üÙŸé=_ûš^xòIµZ-U«Uõû}µZ-]¿~=ôÞo¾ù¦žyæ½þúëÑwD?ŽŽŽ' §û¹Ëšó„c"dîÀáÐy$×÷%d€$9íCßOµžZ­ò³………˜gHñp(*Mó¿°w’b_õb ¼+€;ÀÇ`?t§€ã…Mä^nCØWæççcž!bm¦zg×ÝuÍÀü¸Ðm;ËåF Å&ï ¿8 å{$7z²k3aau=tQcs",J)5Œ%̃W~‡"ûý~cÞ¯T*ØñÍMj.—‹zÂÃá0Q¿pMTáèè(¦`ˆ%)ÊÄyÉ1iZŒS$MCækÚìI§$ôºÆÖOåÝZ­–666â]$%jL{9J68)Yû›¾Lö—¦ahIðØ,H¨•2 æ€K‡$…®Tš*†Öí¾¤5ÑGD\¼ÒºU¢D%`åÒŒþ­[·¢ý„¾QŒ}åg¡PЂööö ët:’Ì"s§Ñh¨P(¨ÑhD40L›$E¢9Ïeí¸ãê›?öÍ7ß”4qލeŽ<éøø8¾^Zš°~+++‘ëÐï÷c½Ôjµø/Ù ³Í½¸/óÉ8™#ù|^ëëë±>%÷ߌ±X ÇÌ ‘€ƒƒƒÈ…¡mÈ kÔéßV«9*8“€f¤VNHlþÎïèÖ¯ÿº–-'Í%8œÈŠ3•Ífupp +W®G¢÷ê§?­yMÓõõõˆD“+ÉdT«Õ"ñ¹P(hwwW½^O¥R)æ²;ë86؉t²|­V ‡®ÍÏON˜Æ~èq¶‘à …HbugâÛÿàèÑgž Û‰}€}ßß߆¾ÝnÇÚ ´0!"#ù|^ÿí—Yïùò—õ­ÇK/Á#R ‡8ñ¢kØ4ûÝn7q:4v{4E~'Œ3w™Øæ#{âéé©zè! ½ñÆÁ¢ÊqÜîÐ_œLK[mÂÆQèùçgà0“Ó‘Édtùòå ‚è{H˜µµµDžÅìº{¯˜¿×êêjW6M \ZVƒ°8»@’‘¤0(v%Eø•ÍŠûÃxÃ6¸m¯¤Då—Rp5Ø4HruðØëõ"ÉD–¿¤`;lÁŠH è%a÷Iz…¹°>]ËêåaŒ<Äh#áͲI—gÄ:::ŠÍŠŠ&­V+œ7Àúd€9ÎóÀ«$^Ñõz]W®\ €¦8“É›ÎwÒd3'x&`‚>¸²1¢¡%‰SšÊYíó>D x’Á$ÌMálúVœHkûs|àsËå¢_'ΠONOOU,È’$…fœ1à€ žMR(߃ýGÿͼ Á¸Òô¹¯SÍêêjHr¹\~åígÁ}8ÖÏ(—ˉŠDh¢I\æÿ8õ0þ8=È›Èí`®ð=—=¸dŒyÇ‹EmnnªßïÇz‚ †IfÌi{íÎZo·Ûá4×ëõe€<cÀ,À˜µ•Ïçµõ™Ïh÷_þK-Þ±ƒÏÎÎT¯×£½Ô‚gŒx×ããã`¼;2¨B¡ ^¯R Þus||k‰hŽ;#«««1Çs·÷Þ{¯._¾¬L&£W_}Uûûû!aÌårúƇ?¬=óŒ^xòÉÈŸZZZJ&)œ/JpbS! p>÷÷÷ÃÓ/ÒTCN^Î7ë[î6Ñ#¹Œ3À™µô§ÛíFu-ì"Öy5"'n½ o‹“‘Ëåbþ¸douuUF#ÚŒìû9pçùèóK¥RØ)¤ñx¬|Pï{ßûôÌ3ÏD>s ÛÀÿÝé™]wß5«3.ÃIXh -XIT¼•%œ…q†¡%éZ@× …0Z°(T[áû€i*lH ö‡üÅ šG.Ò†A„õDÀŒ"_€X’GÜÆÆF°óóóq §DærÓúØh8;; P ˆ†QfsáÞÎ0‹ÅÀÐW8+|–Ê$GÒN×ÊÀyÁAc3¤¢ý„äç‹wpg ÐĆ tÆçF™‰"ã,%Îs“ùp£o]¶ä‘ >ë²0Ž®ÙE’¨æžªè?€èìì,’[}>à °žüdJ¤/î„Q:~"eðµÀ@Q¼`Šs#N"!ɨDv˜wDÔÈû(‹Á€ò;æ'¶€ö–J¥°È)H8ÁD#Oƒ}fJJ8Ôn#ˆqvƒç7°¶©^5??rú§Ûå 0§÷~þózåŸü“Dâ7s…~Á>…ñó5Üþùü "!Â|#A?“A4’µÍxzùPì¶;¹\NÕjUëëëºÿþûµ¹¹Ò$Þa8ê[=¦ŸûêWÃ&cGòù|ØUÖ2‘—9²Ï°Ç`×YÌí£££E!ÄAbݲ>ˆºxt‘~¦-hˆæ;û”K!ÝÎz¥Ö`¿ßËÁ[Þ.æŠçÃð{rZpJ‰Ô±ÞÈKÃ1É M.»ÄÑ#ˆè2¶œät^Øìº»®3.ä®-% #íÚS˜6VŒ>É@l¢+++(ü(z$<Ò´~º³k’‚ÑpF• c sÑh4Âéx:ˆcc tꀙgaÜÐöÃpc<Ù±ÐXZ¨cê‡ÏÏÏkmm-X§V«`\€r¹ì-ßFj4 Ùí*‹Þ†Á‡±¡ÀÞÃRñ]ºWrJßx5@8›®ox”žd„•p IDATÃaƒ„•óÄ2æX½^Oè@³îDÀ:±A3iö=¶ç;P‚q˜¸•[¼?†Ãa€tÔ¼Ÿ4M8M'Å!ÁÁèt:Qž‘6ݺu+À¤u°ƒAÈZ$…ÃÂ|¢? £ãL¸V˜{4ªððsd'DŽ`b‡Ãaä Ôj5 ‡“£çÑÕôON&õՉ䅈zéÒ¥Ht†Çù-•J IrlR¥R à À…³-)ª¸DAš–†ô1·úý¾®]»¦F£kéÆC_ú’z¿õ[*¶ÛQ5Ó×T>?) èÑGæ)Îö‚uN’¯;«8éƒÁ@N'‘ ÉC U«Õ$)Q6•¹„Óër7œ"Dt˜c8PØíˆ~žœœ¨V«Цì+öLj¨ ïÊ80W< ˆeMÒwý~?æÁx<Öw\úú×õüODŸ5⻀n4ã<žH Îmt‡Óåõ`=oll¨X,joo/@8•°Ö××cÜz½žnÞ¼™ú®‹Ïf³1ûûûqfÑ6ú{C_áHPù‹ý˜uÁ„”çàà@­VK»»»qìŒWCã¾³ëî½f`þ\éJ,^Ñå&è& ÁPa`!¨ÛétBk977Œrê”î`^TÀÀÑ>Ij6›@ب¥éAI„ì½&3›Æ ërrrl¼L%ÌìNF©T M$Ï–&›Äþþ~lä.Ë Om- ŽmÌHJÔÞFöÀ&ïŒ 2ä;ll.°µH«$%*œ‡í!W‚gÓ®5Ô åáâ>”*dœ˜#ž4JbªWÁ‘:]O|sÄÏ}™;<ssS…BAûûûQ„6IÓƒ˜ üÖ‹7àæ ¶p€³{rr¢^¯§J¥óÛQ-6Ïn·«íííhQžÎ“j3™L$»n“PŠÓXD/žÉdblÛív8$78¸.âJØWÀ·³™ŒL9ºñR©:ôÒätx¯[î’ñx:(?Èa:ÌA×û»ÃÂùÉD~ˆ$]ºt)ú '—ÕHp&*‹Ý„QÇq8;;S§ÓÑÜÜä =$”0ÕÔqøONNT­VCûŽ–œyÎ>FT2bnn.Ê|’Ë|‘¾cž;0æß^™;8uxxK¤90õ¬æ5ëUšÊ«°yÔ¥§Ü(² N§‘'æóµ„ÍòêX³ëî»f`þ\lâ$¡¯DWMX\šjæ%3PvP…á¼³‰4›Í¸ ˆ0&áëN§£ƒƒƒ °œ8®·÷p(!PÊ8½°Ï³1´”º[XX&Çë4»Á<::Òææf°gív;€<Nú†Æ ý·¤Äf„aæù’L ëhad•J%X9¯º^Ÿ¶²aq¿áp•`\ÂFD›ø¼Bœ ØcIÁ""!ÑëV/,,D5új0à¤?Ý90Q`ƒlduu5Àæùù¹®\¹¢w¾ó:??×­[·ô½ï}Oo¼ñF8Rô?óìàà ѸÇáe“÷¹”Éd¢ª‘!—ª1Ok~NkæÝÞÞž$…ô‡âòåËĶ··Õëõ¢‚ŒG¾˜/ÌCÖ7Œ‰^=ÇÖ»êõzQq†6®­­…fyaa!ªaŽ¡5f¾3aæa¾‘X¹CNr%óߥ ÌEwXç¹¹¹8ÿ"›Í†}mm-ªç0a&©mßn·C22õž¯}-æ6My§ÓIœ³@µÆGg<Çz¨T*¬¤‰³Hu§˜–J¥`777 9`É×úúººÝ®:NB>Â|!‚®÷ððP«««‰ºçÞ6/Ðh4Ôív#šx$‚‚ŒŒu‹ÝËårZ[[‹Hûý„q©ãÌZyô™gôâÇ?ž`¨ùü`0P­V ö'—œ"DØ(À‰µDzpd˜—n_ÎÏϵ³³ïE]wä>îl!cÂn1ì18Ã<³R©¨Ûí¾%"ŒƒX¯×e\]žŠýG2ã¹MTö¢P&“‰{!3cÍÍ®»÷šiæ/ЕEÞwÀœþ¼4­qÌ3îV¤©t¶ ™M9ýyŒßM?—gÓ^¯iïÏã³\R©®­E’")QÙŸÑǸòy˜[? ó<׳ro¾CÛ/×û§Ç„ßñ<@ºoü›Í›±M‡¢ýé6z².÷¤íþYÿŒ¤pÞ˜SüÎA,óWZ åïãÆg},———µ±±¡k×®éþûï×Õ«WuíÚµˆT¸¬Ç¿ëóÌlj6xõ—ìð}úÕû‘{Î}îïäs  é-ãìõÅy¾çUˆ\Ëí}͘y]kÚæúr>K‚ƒ­üY.‹c¼èc—18häÿ<— Ûã¶ÂŽáp‡ÝñÚéýéïîãä÷M5ã}û7~CËËËqr´âC?SfÖÇš¾ zà _Ð_ý꯾enaÛÒþîé¶ÐVžÁ³Ý®p¹MNk =GÉY^ì&cæÏ ¯˜8bf·8#¹\nÂÎ?ýô[澷ןëöÉ×™¤Ø0ßèK¾ÇØðîþ}ÚL´Š÷r;•^ìC´™Ïs—¥ûŠÓþÎôQ¿Ò{÷s2‹Äa.ŸSžëíðõœž3Ìë´Ÿ]w×5cæ/Àƒ‚7ŸÏkww7Bþ.A§C ãáºE’ÈÏÀpæóù`ä·æääHXëÕÕÕDå•tâ&l2þëÀ¦rI°hka±~œ¼ÙlÆçøƒœF“°«3EÙ\î­e I¤-€ ×LÊ') –Å7>C²ŸkÕ Ó:³CÃ阜€ ¨[YY Ùør¹IeŽGG‚ãßïG¹ýÚ¯ýZÜó¡‡ VÕ«¾HŠrxl~^ÉÍÁÁAÈ4ÐæS&•üNíÍçó1ïa#½D£ëWED¯:N¢.H|\SL¢&ë’9³¿¿‘X^äE€X<ÚCÒ*!œT"b°™¹\.tÐŒÙññq¬wØ\Þ½ÑhÄ:Câµ¼¼UzH æi §¹\.ò°?ØiR›@¿’ Lä€\Oôc!i wgݹÿþû•ÉL*¸ìììDtƒyÄë×£±— åÙl6æ;4ÆÁóŽ`Í%%Îì€yv)v&—÷ ±nI.n41×xwœ ä`´…äz´û°ØãñX»»»*—Ë!sc²&ú˜|ú CD[øú믇T‡5D@’vwwU*•¢ŸF£‘¶¶¶t||¬ýýý° ÃáPN'¢ÊÈ=±Yä3‰f&f³Ùˆzò|ïÉÉIØjæ-y+D®ø.Ò7ªö0Gçæætxxö—(ÒNìïÙëõÔét´½½­|~ZÛ ûÏÈ~ÅÏXs8>¬¢Y»»»QÉgvÝ½× Ì_€‹ÅOؓЬ).6-ô¦„¦ ÙùA+’B{ëà £Á!B°=®Ý%Œ hæY’­8»ˆÄÐóÿÕÕÕõph‡hú€ƒqÊår€_iz€Q.— ­>†Í{&“ÑÚÚšÆãÉáH€K´È1x7B žÇi BZà¤M«««!À±‘¦"š5À¸.,,$rh ¦˜£°[Èh`ÄÙh`Å¥dÍzÞa0¨Ñhh}}=6E¯4Áw3™IËóóóJÝnWGGGQf¿ù½4Ižs¨T*úÀ> {î¹'*ï0‡?ô¡iwwW·oߎ~¡Ö62-žÛëõ¢tïÃzªä ]ÏØ’œˆ$† YÛÜÜ\èÅ» q§úÚ×^{MƒÁ@×®]‹„^¯ÄG‚á?tøÎgq ¹ô=l1N²æm¿ßW¹\Ž9ËNßK“ÎNNNà°¥¤Ü«×ëéÒ¥K‘ø^­VÕívíâ}WHšøº_ZZ I‚Û&ìZ&“ ù ve8œ$^¾ã‹_Ô«Ÿþ´†ÆŠ2'xWœ^¯§­­­è·½½½pŒY[Ãá0ôä’"pÐCÅ8x&‰¥8B•J%œ®Á`ÉúØTœý………8áêÕ«Êd2Úßß ÃÜYZZš”ªüÒ—ô“OXö$Õt ƈ$mÆÉíº³æ8m$D#)CîÒ¾“¸ŒLgb×HÐ-—ËÚßß@Í:ÃNR‚èÒ¥K‰è I§H{°Ø,îÅÄ®»F¿×ë…ƒ†4“¹ÓO¿µÛmU«Õˆ*¶ÛmU*•°¯ÈŠ<™œâ¬Þ¥T*‘Æýg×ÝyÍÀü¸”°a0°ñkI &ðƒ!÷²k™L&Ø:€!šJJì¡G£íR ¶êБ{–¿Wáù°¿Ò4ÜJeIÁÃð»D†Ë«À˜ð‡ * ‹ÌÖݵ‘‡‡‡QÞŽúÅaÀ` 2àœ±òZë0¨ gµ¼/`ÐcX>ØY’|ù.Z|ò"8ý–ˆ õùÑ`€ñî€ÝR©}Åó …‚êõzbìy.›·³rÙlVN'œ*ÚÎxye’è¶¶¶´µµºu@ÕYÎÎÎÔh4‰ŸÙl6œ%ÆõôôTN'Ð%¤Ù ‰lÑçÒôHæ=Žëæ°ŒÞÕå-|2U(Â)ä³^Ñ#%â˜;$Z’¯@QÖ“Nqèƒ;¬…g?ò=ú'¢çŸx"¢”år9QÕ‹¾ç{Øyl1{ Nž—Éôr³¼óž{±v=‹õš·9¨'záß!a‡É£uì­ž îã˜Íf…Xi¢`0P‡ì"úÀÙ ncÒ’³Ùuw]³Ñ½€ÃâÌ!SÀ9e]j.M7!JÂ~¸a%ÉŽ à€ü…ÄW èùùy”ŒÃ(®®®âà$­”Ä|b`½|œ¤¨'SˆáEêÀïÛívÔ#æ=1š[[[QšŽ öü|rÔwZ›MÑÏH xWB¢ãñ86w€u.7IX$úÑn·£š›pZ[ÎÁPÓ?Î ù{û{ÁR90 p‘¦õÇùžk–aÁ(UÈýè÷tiA6`úØR×Û¯¬¬h_ãñX¥RIq0Ñx<Öþþ¾¶··µ´´¤k×®+urr¢ïÿûúÁ~ ~¿¯X¼‡Ÿ…pr2)ÁØl6c¾ã\ðy’aaøkµZ$5ª‘XÁLžÅš€‘ qd€pl€¯4I¼ì÷ûªV«ŽçŒ/ÕI¤i)K@ÃíÛ·$ ‡Ãˆ,øÁR°´¬e®N§vƒg"é4ðÇzá3Æ™ˆWmÂnà$°¦p*lždŠ]í¦˜_Ì –¯ IaÓÒzd×FS] ©R&3I¨'×ÄKVú}2ÐØ©£££¨´¸¸¨jµödH€çææ´··—Èï ¬¨'„JÒææfØÓƒƒƒHPåù8IT}Bn±²²Ž©;ŒE>ŸWµZ džŸ=’¦‰£8Øw©YëédK@-‰º.ƒ$¢–Ö‘Cžžî ˜(1ûöIšVØr&š1!ÊÇ¿)iL$ bãðð0%Ú†äQ ÆÀÇ¥†¬]¢Ü^º’µI¥+æ1{œ—┦§1s2.äËÖÖVØÆ€y2»îÎkæ/ÈSBŒFMRT‘pá Q°Th¦Œ–Ÿ"éõ|%%XJNl”&âíÛ·r6gi²AÀfa¼; “4­|sûöí8ŒFš²8¼W§Ó‰Ê&°ÓÒ´J6›Õááa€Wî {L8§Æ%ÕègÚÈæƒ‚~š §P#)d€"Ú͸9ÃëŒ`’È2›r¹¬\.§V«ßcq¬¨éºÇ8Y£Ñ(6©ÕÕÕ(Ç阗.] †™1B:@8¦¹…¤`ó1€@@·ÛÕsÏ=2œ±›7oê…^ÐîînlÌDdpè`îÎÎÎBæ€3åUŸ5ÐwŒ?L¯:ú: @Ê8«”ÃC[£IÞÈh4J€!ôÂèú™{=:<< yMºZ 0NYVæ,ãíy‘@2G;± H•h"Üé‡=88€ SЬŽçt:D|ÖeS™÷°Âëëëj·Û1N8_¬o.ôÓÈ766¦,,,„-Ķ•ËeÕëõa7¢Y·{?ÿy½úéO+wǹá~´Ã$j¶ãÌ -Ä>º4ÚétBþæùä ‡Ã¨êåIª”%RÄüE"â%s×ÖÖ"’Ñn·Ãf²Ö±‘iÇ~0ØáÉ'õsø‡záÉ'ÃÙǹq™I‘â%É…@Žƒ£V*•¢Êù=&DŠÈkÙÛÛÓx<ŽrŽŒ7ýÖh4âó^l3Ñ)îéI¥Ìú}É“n©2ÆCDÔO¨%Ç;BYOˆ*\ÑÒÔÙ!ç‚÷b<üð>I!íÃYÄÌ®»÷šù pyH©€kÔ%ņ!)±q7`IÆg½‚%ø¨u ãJT‰yCNNN"²•ñúúXð7Lq.7)‰èÒ ˜í………pÔs¹\j„sÂÜ$¢€üäüü\)h4á°2w;1o/ÚÞív#ª×jµ‚EçÜœwµ¾¾ù.Ø?ÚI­s#ú–ŸQî’r€8 Ò´Ì, Q6·DŽc¾äS?ß¹ÀÏZ­–¶¶¶"Qœqî G›œîál¸?@;ˆÆ›±Á¦`3Y—.ÏòH£4=ËÁs›p\T©Ts•J¥°i¬Cˆž»²²’)¤F”E’™ËåtppI¼Èã ú€DPÖ‰Xh·Ûo‰äò<ö¯¡ïQ…l6lyy9¢·${r!]>ÒOi÷ÜöÏl6‘Jì‡çl¥% éhõìº;¯™«vA.ØŽ´nÎõ†Ò”yp¶žïJS–Ý%^úË™LךóÀ R/Ç}Ø£ÑöÒ”|FR0ô0É´ƒßä¸\cìl ú@¯— ô{x¿yÙ96Ét>×tærÓ²„¾‘9³è÷AàÉ^žˆå¥ó¸<„ÿ“Æž‹ñòßñ}6rÆVÅû±Ñ0>Œ›)ãïmå™l:ü$…ñbìz½ž^zé%½ôÒKÚÙÙQ£ÑH”^dNñyæ'3öŒ9mqÙí󹲺ºúÍÛ˸ø˜8ÓÇ;¥K ÒGÌÎT ÿ¸þ.^v˜g²Žèæà‰çÒ&æ—ƒ+îC¿Ñ_k^ÞÏîmOÛ$€c¢w>÷ü{¼?’Ëg¼t+¤CúBÎÀ3ÜnÑN¯“^»¼íãrûÅàòH„Iº¸ˆŽ.;â¾½^/œ ~FŸ¹muǺÑhÄç´L)]nÒ×?_RbÎúŸq ÈPxßÑh¤[·n%œÖ:Ÿ°™ó¼ בã`¶Ûm½íþ@/êSš»UCúǽ‘‰Àˆ^ºt)Ö¿ts@csxxýÍ€­wdž$qì$R%æƒç»xICX_ØaÖ$ë“*A€>lý“Ëå"¿[ˆ¼ÖÀ©ãC¿.™'ô5ó|\nZ¢õõ×_*4EªÕjæqˆÐ3FôO>Ÿ(’,ªÆ0G*•JŒvÚ2ƒ•¥bÌÁÁA<‡ª.èÐqÙTÞt ™d0?Êž$ïQœfbÀm:;;S¥R‰±åô`/Gš¾È]À>2ŸËår0ý§§§!?Ãf]¾|Y×>÷9Ýúõ_×ÙE¹È^¯”;ô)v²‚uX¯×Õx`ª! pzVq‘cÄšÃ6a[h6’„<'ªªd2mooëÖ­[!„@i4Q…Èk¥}çñÇõÈW¾¢¿ø¥_Š>'!³V«…ýÉf³ªÕjáp2}½±–š0'q€]¢„ÃÓͿɀXìâl#Cã÷ËËËð=’á8Ú%)@¾3ì€q\)&€fž3@Ðîãì²¹‹“ÌÙïègÖŽWÓ¡Ïpdóååå(Á˜£ÍŸ]wç5óàÂãDZAžœLjɔޔ óúëéä(6_ibtJ¥RB3 ¨t*ø7õ½1¾0*°0år9X=6*´¸Ï>ûÜÿð»?øàO‡¶^R"y–*>03θy56úƒ¤Íýýý`¶ÁÔFÆYb#r`ÁæûHäÃ5ÑŽj'ïÒÿžÏÀa-üÞ™ÇR©”¿€lb$­y™RX~€¡—¬“¦É–¼ å ™{›››Q!åìì,€ ôó«^¯GÙ¶Ñhõÿ¹§³¤»»»‘PÆ{’¤ Hà¼'ì3í„ÕÏf³Á°çr9FN"܆‘q£66€……mll(„™óC“ãñXµZ-ÚM„hyy9‰tÙl6¢Z‡‡‡¡Õ—”8L t±X ;à‚yˆœ„¤T$À€j6›Ánz"Ÿ÷Df>ÐFC °s-6“\.•€H0&‘“Ü’|>¯z½‡’q0Œg¿ßñà}ÉóAkÞívµ¾¾öGäÐL&£r¹¬f³©ëwÆ âIÈ„ÜÁÑÁi$ÂX,cýPÀKŸ…C ±‚3éëþìì,ÞÂögcˆ\y§jµí%φjCä00ǼÞy§ÓÑ¥K—hF“ªZ¬u@h¹\Žü@(ZoÞÅ#p¬!ì1v’µŽÍƹ'¸¼¼œXë.׃”bÏa¾:¹B´ÎZöì¶'˜z‡……íììÄþ‰í8<ü*“™ãšY0¡«¥<úÂû8³èb.ò=»G[h ¬%ïÏfͽœÍG2äïçÕ(Hàãg.—q],ý c~òÞ ›¿ÀÈÇŒj?éyƒ¤ P H!Z577§+W®HšÊ¼p葱ür6Ð#R8GHž>× ?IÀzti‘¤è+H¯î èô±·â‚hŽ ‘"g=Ý...ª^¯‡¬Â«YÁbC°;Nâ<I!éò|×ÅÓgŒÑÚãQ0Þß×$Õz\ŠÈÚ Q=Š3`˜;w„Ýáôp¹QEœl%ë‹r»ÈFÅ8n¬É\.—(é˺pM8¿óŠ1>Ç™WÌëñxzº.Ñì"ëÌ¿ƒ³DÈ *Ÿ›¹…ñÊVüaNósÏsà}|ïdÆ^yÔÊÁ¹'âcÏh×ÊÊÊVή»ïšù p­¬¬Ä‘ç„à|ÃtRÁ0†!gã…!¡d" ^šê5]ÿçs´ð<¶ˆÆÐ,, ÌR¡PpÊõ¡ýO:?ï'ªüüÏÿ}ýùŸÿŸzóÍ7%)±ÙÞv33ü *ÌÍÍE b1hñ)Y ûˆu  è"Y²Õj% àÅf‡aç¹0Í„o+•ŠZ­V¢,,ÞÊÊŠêõz°S€ÚÅÁ*Ùl6€Œ; €cXD/ÿ‰cT(¢d#›2rØtØMƈ~Ãyôp4ò'JèáˆðÇ= ,/)Æ›wõãìyæ7å™[lòm¤h€Bú½X,&NuÒßÛOÿD‡Ž3Û‰Ì)›ÍªR©DEÀ#ó°Øð¹Bîë’>BVsé5ù±îäF\j«9 T­VãØùR©Ïf,\F®'»²®ÑbãTE¢ü©G4`š²Ì‡v»­B¡¥©“ÖŸŸŸëÆÁºz.Ž>²€èââb”bdÜuÛÛÛ’ý Ø%¿€<ÖÕmˆIF‰*2^!…6q 8NöââbH¤¢ 1{2kþìì,ÖÁââ¢:N´Á‰Ùu÷]30.’¬¤éaH0…Ò´5̧:¼{6rØ¥ú` Ä®o$$ÊiuؤéfGÂiZJ‚.ܵÙ=öóêv[¡?$´šËåôÁ~@?üá·$M̘ãPÌÏÏ«R©Äs1–€Pd°,´ÐJøž¤D€1†™w#Y -/šZî k*MÁanä1ÔÆð“$5N“ÝH ÇáÀé,™WwðöF#moo‡Ù Xðn$±¦û’wü¹qãFô™4‰¢ ¹ð˜8$ô`6ÑŸ177ÚzÏ AŸî¬6àg¶ÿW«Õpœ`Ùé  Ìh™‡$ë‘„‰£Ìf H"†;í²„……U«UµÛm‡ìää$ä8H»82`B›aêSÁÚ·Z­Ó))Šgþ<R”©e=@à Ðèó;RH“„dg½™ÿ8+i;@´ŽÅr¹É!kêÉy!RF. ɸØ;¢t›››a)ˆ#‹„]D¿Ì=¼üçp8 P~tt¤ýýý˜?ŒrR©ý²°°QNI‘o”Ë增úîîn"2äzqXwÚ5 ´ººª¹¹9íìì ¤q"jµšÚívD `²a¸‰ô+¤Î—G†´Ì?€´WžñhâÂÂB‚Åàμ+kY“4-§<Õl6µ¶¶¦ÅÅŹñwžU©TT¯×%Mó$kæÄïÀ!m°ú8÷Œe~‘Ä¡ÀQ!ê̼f­@è4›Í„ãET‚ƒÈ¼(ƒ¯YÚŒœÈ#7>V³ëî»f¥)/Àåš:Io)[ç¿óL0ºÅ““iéI„~aD`Ó¸a¢ Þ>®ß?]NÑßßñ]ßX¹ÁÐ.˜#ÿœÿí%ðY{• ¿7L<ý‡öש(þÿt»½M܇j ^B.^M—]„‘sÙÍ{Ž—·ó޾IûåcíåÕü=Š’.{Ç=¼üqyô„ËËz»#gNÓãDB¦3‡Î|3&èO¥dy>þ°fø½·#Ý6¾Ï3NNNäþ8ù}I¸¼À/O^gÓÎô ©þ}o ÏP8³J_7DY¿ÕÕÕDÒ ßñyn7ã‚ð5ÄZ+‹‰Òy‹‹‹ñ,æ¯ß›ò}’¢Jsæê`0ÐÎÎNŒoZž‘þ7÷p›èÏö2·”ÏdN@:HzË\â»üœö¡U?99‰²ª|ßçWz®ñ<ª´ð'mgÓeL%;ÎÏX÷nÒ¶˜ˆ‚ŸµàóÆ¿ùë§×?ãs€ïS½ÌÇèÄAð¹Îï} ¤íµ—¥MØwæ©ÛÖ‚®È8ñ}æ,Wº'óÖsÌ|ïM¯]*‰ù:ñyÄúÚ÷±bìyGæèO²;³ëî¸f£{.׃ÃÁÎyÙ4ØHŒIhÞ‘7HŠÃLH$)ÇïæÐ™H5V°å’â³<“p}.—‹$ iœÀ’Ãd!pm ïã ûC¸’Ĥz½®«W¯&B—„ª©ÃíJ@,›Ñiz’)yô ,0L-ì',LzVw ˆ ðOE’Îòàà@¹\NkkkÁóþèj³Ùl°T0a½^/jûóųÑ_ÃR¹¹}û¶jµšòù|„ÉI(Ëd2ÁR–öþääDëëë±Á1î’"ê#%)æ›%J¹˜W™LFÍf3áP]|·ÛyÃï²ßÔ©@3æÑ’za×`KI>åyHªVWW#ñ‘fW¤nçççÁ4 µÛí`ù2™L”ô#ævÉ ÷‡e&ò–ËMÊ»6›ÍÕ0gÒ4\ﱘOH‰Òë›#)q".r–V«6êðð0d[”?åÏöövHXÛÌs,s ‹—"”¦àm8jgg'¢&D5W4æŽç6P…©R©$ªð` \ÃÍ<üR)É ‘ÖeµZU£Ñˆf’œ!ShûòòrØ ŠÌ]Pl)ó6›H¢ë¼éS·¡Hƒ'Ö°3äœ7À™ý~?ÖÕm| Ð^úyIQ’°Ûí†ST.—%I{{{‘[Âø2ÏU!5999ÑÎÎN$û" ¢ÏááaèôaÂ=ÁIž¯tÍnÀO¹\ŽþM³×DXTgIG †ÃaàùôR¥J¥”Hò%Âgp`x2†H*;I±np¨Z­Ö[_úÒ`kkK+++:>>çÛˆ¼d}}=€7Ñ8IQ¿Þç:v[ʸûx²é/$ƒ€îÁ`IÊ´ [»0éo¯S´‘çòs¤fØ*!½öÚkÑ?ü°êõºvvvk’Ê÷Gr­é±6½ØVÖ;¶y'¹6ý~_ëëëád0Öä8á ãì0°q¾_Ì®»÷šù pÁÖ ç…iàÂŽÇãDe „KDÚív°ÔÇÇÇÁDqˆgßÖ`'ØXaíØä< M¢)zaŽpg³¤ÝÏ>ûœ}ôï…qõäµï~÷y½ûÝ?«ï}ï/b ÉÍu”Tâ ðJFPQš&…úá-¥R)}‡ÑÍçó¡¡%‚…õÅ鑦òŽ gó°ÓOTú`Ð7^Ïv†wÀ¢ÙÅ©ã|ú†÷"zá 4ö„ÚÑ)£¡g:FS cìcZ©T"!Ñ+šd2™(ýˆœÇ\YZZФitð°Öè»Ñ”ªÐ¨ŽÇ㨅M¤…÷DS¦‘vdXóóójµZE"9Ö^šjõDÀlúÙ’U-\K¬®®@õÆÉ oƒe,®8'ÌEæ;`vkk++y/æ@*›Í€–lm¹\VÔË…’$»¹¹†¼ÂÑ=$$74°éD6HÊÄ)"i‘9€ž_Jž>ëUb<’H[ѹV^šBúq„€èt:ÚÜÜŒµDtƒ9Í<Âi‡%§ô.‡"¨Y¿^—n1Ÿ˜CF#îÏ{ó^^†‡}Æ)tÃ%T´—ý›ìy0|¯Õj©R©DdŠŸc`ÿ‘YÍÍÍ…3MŸqßÑÑQ$UcÐá“÷@ñHˆr¹'{$}I´•ˆ!Ñ0OvEû> Ôn·U,ÃþC!bþ°§¹Ì vßuw0}:==R´”ò¤Ý“&Qjˆ-cü"7â'IVg×ÝqÍÀü¸,vŒ+Õ$¼t†ÏßKSJSP`gƒòìyØEIÁ8À’ÂÚÂÞ o€eIoXÜÃ+€p}ûÛÏêÑGÿ^ü?—ËéÛß~6ÞYJS¾È.<<ê²Þǹ €¶Õj%$l,’üQ1ÃKÓjx6@M€ëQ$=×ãã`Á–îO‡S $ù“wõª ’¢Šc±²².}Á˜ÓnZÐo~›-Àœþ`ŽPÅ„¨ï (–Ì;@äüüsÂË;ry¿@J!­ò9Ø œ$æ"‘NŸW°ö¬Ítþ‡ŸîQOÚŽ·oôóÛ@»¼ÚýéórvÝ× Ì_€ à MuŸ~Šž4ÕDûa7Ò »1a“Çha‘Od2™(™ˆæðøøX’¦FPäUl½lȰyÞãgö]ÊçózöÙgïúÈ#ï½öž„Ë岎Õl6ì‡gi¯WEq%'¶(q†µV«Å&Êæ“+ÆØB#šÍfã '4ænµ»»«r¹5‘qº“L&,&eé\Ó (ËårqÔ<›1ÀÍ«KPUbmm-¡Æ9 \Îs(3“æ h°ƒ,>ëì3ãÌa=lª8†ôSzÃfð\6ViZEÖš‘4uðæææÔét´²² $È%*0ð¾nNNN”óÎŒ-•‘“Qá†¹ÍÆË|çâ{D xWw®aãy!>äñõåÌå•+W""C¹CNLÆ©ô€âŒ5€ùS&“Q¥R‰¼ÃÃÄ“·±±Líh4JDýˆ¼ÁlÒo°ìÕjUÛÛÛzðÁÃéßÛÛ ðØõhë—¹Á¼–&ŽH©TŠy@4É%M”²ÕjµpH‘Œq_? {ii)ÎOð‘tФö˜¼ÚÝl6c-Ýb~©„Á¾sïZ­–™0nƒÁ ôö-¡”!‘ÀN§§DC¬ôû}U*]»v-úª)°ûÌQ/¿É\¦4&võìì,Äæaã±7år95‡â}èOÎ|@6ÆØpÚMÌårq"4¹Ìsä{ù|^¯¼òJȾpêaë3™LTšò'D…ï]” e}2Wpê–——U­V•Éd‚‘'"…£ Äxz)Ö2ƃÁ@­VK›››cƒÙuw\30.?Lƒ ÏŸ‹ÍGš"¯ À`wÖ™‹—ÝÂhÊŠD ¦ÃáPårYív;$:h_i;û/þâÅû®ßùÎwÿwM¸K `€=ÁÆãKÝbÀkú½phœÌy M;òœ½g|œý-—Ë ¶ Ýý`0Él>,åÑÑQ€J<¡'c€¤9ˆ;AÖF#’^Þ騆—]sŽ{Áj20º$÷!‘‘'@ÁëŠû& +Ê|åw€!Ø+¯ZóÇÉå¥*]ƒÊãPÐoî°0ÇÏü»¨å².îCY<ô¯~ï}rr¢R©‰§8•8ÀÞ\n’7AÙ;žÑh²(œXÚÀ^&ç„yÇ{1?‰VD2,ÞùK_Àº»ÝAZ# ÈÂñfl™{ô1àg;Ž'6A7Mž ÿôô4æ!ãpp ^¯§jµß…5,ïîî&œ4€¨¤£€K’¥kµZä)Ðï8gŒ«W_a>°F°o^Ž”|löuww7Ö:#’¾i ú~ª1†>Æñl6›ªT*!iÉårñ¤€ØSÖàúúºvvvÂbÍÍÐ#BÞÂûC8`ÿ<"Ad¢y§G9å¬#" Hãx>N/kœ½ {3â¬ÚK$Ôm¤ç¾`ÿyV.7)G¹»»ßöñœAœr¯\ÏïŽôìº;¯˜¿—{å®çc“ ô.ã{+@¨1]êÍ% løÝZ­`]´³Ë°­üfˆ<€K>Ÿ×ûßÿhD8øÄelÚã:1æ°1‡‡‡q¿³³éɲ~°€‰ƒc`¡x6A×mÓWôÅþþ~0p^]ƒj%N§ãàl÷d3C›Éd‚}sÉ , €ÈK²Ù¦Ojå°Xf.êt:ÁúÑN€;GGGªT*!òq€¡ãý`|§§§ÚÚÚŠÜ+%!‘ð#©‘”¼î¦n6ïhét:‰ƒÐ$#Š–œcÌ}¹mhÒw^¶”MߣN0Þ€œ].ÈžØÀ=O…*&ä›ÈG_x® ý#Ë»Áì6 mll$*Ú4›M‹Å3ÈϘ/XÚFr7 ¤KKKqmœ››‹ÌR©¤N§ÑH¢#æ ý1õæ›oÈÏd&•{¦H!kDc°cHB܉Â铤µµµ°°æDÐp4aŒ‘{ÑnIú¯¿ð zÿ׿®<õT8JNNHGzqq1¤>ÿaX{½^T’„qöÒì7ší~¿ŸHœ~ûÛß™`‘Iv9m󳤩–`Éä´Vþpϳ³3]ºtI’T¯×õøw¾£g?òͧ2AÆbmm-!sÄæónH¦¼wvvb̶··Ã‘pÐLt‹ˆ y:ä kçLcWwwwî¥Cй€T§Æ£‘0è•J%¢^¯‘»““ݼySkkk‰»Xk{{{±žqZ­V~ÞQR€zH1Þµ˜ç¹TÈ) Z]] ©’³ëî»f`þ‚\„æ<¼Q(:õ´\ìÚfišå,,iØŽŽŽš\צë*s0ƒ]w$‘)î[‘Éd„ºt#ÍûòØ4ÚÅÆÌïÐX¦A8ΚxX)ë;cÌ÷\Ï1vÐî ¶ô»3|lÆ|VÆ+qðyïwBºl˜€Z/Ɇ3é!_€–÷+}ãÌ3¬lv©T gÄYtÆÿÇ]>Ïx7r<©&ÎÁ‹ßŸ¹H;=Á1-/K×Ïw‰ 3Qœiš@tƒþdÜh;cÁÆëù¾»^¯§•••„î—×íN'Þ)ãÙÎæºS6ööS2>§½üÎ˺cÉ|$jÅ…sàë‰( ÙûÌ">›– µà³¾vœÑ¦_ɹtéR€LJÂðûœ`̘¬Ÿ'Ò42šÖ¥{´”õôˆäR椯gþ Cêv»ºqãF<ÃÁ/ýpõ>çw¼ mh4±Vè’,Óýëö ûã¬x¤k†1p™¦×jwð\(´¿¿/¿°sD#‰¶á0³/ /¢¦?ß%Ú…ÃÌ»á#w;Ç{#Ã"ïË£»éó1oæÕ¤hs™qeÏòý±̳F=R–¶ë܃=ŠÏ{§Ùu÷]30®N§£B¡8=ŽMšd#Œ±_àa ©cF8À-MëÚc<8¥“dyyYõz=Œ+ŒÍöë s°àwfdcpÉL¸¤DˆÙ=€¥y´—0Uè*yæx<Ž cн<À§Àà‘ž‹!ö±¢ÿé;´l–~ÚâIµl.ÃaÜØT=±£ÏøISyút—aÖ=LM_°Ñ»pppŸ___<´Âlx´ V›P3úRÞ×e5ÎôÑn6b.$M¾ñ!9#ìÏx²qÒD<±ŒuA{¼>5ÑŒ………„îÐ_¯×ÉÇHHH´–&¥aŽyQŒ\nR‡~?Úà’Ö s¤\æ6Ñ1Æ–ñãwTj·ÛQq‡÷EúD¥ æ4uÒI d~³¾ø‘ j¤/..øb]è"û[«Õ@ÑOô{&“Ñúúº2™LHõNOOõ½_üE½û÷_/~ü㉼Ö ÒÒ4iùE­VK$3ß\ŽEÿÝ#'‡>–”¨Á?ãTUôÎØH·w.·!uýúummmi~~^{{{ÚÜÜT³Ù ùžçD<™›…B!ØaiZŠÔÉ "Sä¦n·«ï}ï{ZZZŠœ‚^¯²¿ÿ›½;{Ž4=ÎCŸ(–…µÑ=˜žž .")s÷EäpHÉeSCްÿÿçZö ¶ä[ßZK\DŠR\DŽ83²hR¦4 g¦{fºÑª …¥±€sþY5ãs¬sâÄ»ñEtt7Põ}ß»åûä“Oæ Ôb¨ëžñ®/})~ü[¿³¿é###ñ–·¼%ã©§žŠõõõè÷ÏN—ÅN[ž£Ã… $¦®jOjtˆ$m||<#&æ•vìììdùP¥C­[äÁüü|ÚNR³Ù̼-€;âLÊÊ9¾sçN´Ûí×U9“^Y~Ç*[e£í#úãüº{¯s0\´ÊÆÈ}ìÊÛø”$™¨ ‰fY[ª®S­*».ÁÉ»E?ó^J,bo+²±æ¦QKÆU6Ù†En4===ŒGÎá©Õ38 $D’#"µµÂܽ^/t2÷Ñóðso› ÉDýÿðï‡çN£ÑÈ~ÎÆêPunÔjuã5Î@̵k×òpºè‘‘‘Ô%ÏÌ̤|@â"ÉG­laìl¸r´CiJ• ._¾7oÞ|XÙÛÛ‹K—.¥¦&[ô5itqq1æç糬àåÂ… )çÁJ@ÆÂÂBlooêV¥0ÀùÞÞ^¬¯¯çZX\\L¶UõzvÎ@/5¹|ooo ‰\^„wç¤ic¿ßõõõ\2¶=©%òÝÝÝ\÷·oßH|Õž*»Q§Õj tg.Z³•¨ˆ¬Ãɼyóf¼ð Ñl6ãæÍ›±ºº·oßÎg‹$lllä|¯sûàà I–~¿Ÿ5éÕç´ö•u®ºqŽ H'÷ÁFûÓjµ2÷Æœ«ÌòpÞÍßþí߯ÄÄD¬­­¥„Ò÷µI¤©Îƒš<:99™9 ík%!õ/g°Ê(,¸xñb:ºUNÔl6c}}=ÜÍ]Îåììl\¾|y ©Ýù$’EjÞç ä°2ïk_ç ¶Z­<d½ÎÏÏÿoá…óë—ó:ó÷À…ÝŠ8ßÂ{µö²PžÏ`71e6¹šÚëõ^b”U™úº‰Ô*õ~~§"*A“ì¨=ûá® ºU ørZ´«aS¨Œ{ ñWæëjR…¤õ©þ83²ƒG·×zêÚíY6Ū7­ÉTœü®†t çÀF¥q yXjÕívcll,.]ºô:¹Î°6_8èös˜ÍM97àD ÷OLLäɹÕÁ:88È$csU‰»ˆSé @ ,›_µÂÖª&­ðÃí¯ã¿¼¼œcZçµúùÚ,ªR5ê«jÎ=F IDAT, ð ©Õ_@ôêêj,--å¨IèØtkO©Ùl&˜¨‘›š|®š•±ªØ…Z±†„¦žVYOùDˆ¨Ô<Ï6>œºwk¥ÙrÕè–w Ó66‡¬%"â½_ûZüðSŸŠ¥¿ÿûtæÕ‘¯ZüˆÈÃÔo øð\ôûý~ܺuk Ö?ǽ–É´~œ0FGGcqq1Z­Vlll TÓ®ÙÙÙÅUb'Âj±«=‹ˆ×ÙZDƒ$_{TxÖ­­Ä{¤H­òVɬaöõs•'VÇa8:q~Ý}×9˜¿G.Æi{{;«¤(g‡Ý²1ÈÇÇÇìà166– ^Uèa}¡eIIdXsÆ€ˆ–*"˜Uv¿J%ä=Ôah´GH&<”7“Ø%”Ûï÷³ÊE­HƒÁÞÜÜLS :‡‡‡Y¾ÌVË^™ÀµD¹ˆ³d³êdIÒ•œkÓœžžŽn·››!&׆èE¹Œ1 Qû˜&1­X)›úÑÆÄÄDüìg?‹üà’"ì<‡š}«Ús9 5ažáüŠtè/$‹ýÕ¬‰¬''g§ÚÚn§d±ƒÙfff¢ÛífòúÉÉI\¹re€ëv»)ç«‘_Žíùu÷^ç`þ¹€_akG{íÀHSuFf›&6qµWúøø8 -ùŸ3tÀ:Ê•Y I†TJ°VÅ¡ïÅc3€g޶£2ûœa{F’Ñ«Úqõ¸o¤C’Àcª*ø.¶ 5›Í¬±qÆžíïïçéšú¥2á@¾ê“ID¢Ú®‘‘‘,ÿWË»a31XtÀ˜®ÊÖU† ;Öh4Ò¹ Å8×ZÉšÆhW»}||<::š`ÂU9µL™žaŸœœŒV«•#ÎFD C ÍÏó9à­jJ9Þ¿V‡©lp•@Е…úc{{ûu’~¿Ÿ‡•pˆl2úXè¶ÊcVsÀæeCå±iÑh¥UÆáYgUe0¦µ‚‰ÈD=×@îpÃY4¾ØLSm¥£­&ÞüŠ8Zž ÐT·Z­”4`üfff+Jf±µµ•É…æ 2==«««¹®\¹’2,@˜ÄÀftp¾€ºy_ ·õ`^y‡ˆ8ü­Ú Œ/y§Œƒ @T]oMF4œEL?à*Ú¤DbMÞ”CòÐívS¾!Ùµßï§œKAéÒ÷¼'~å¿ý·xíÑG’‹)g ÙlÆââb®…ŒëÚÛÞïþêWãÕGIöV)U’*9˜úÊcwÍ×±±±<ÄËp2Œ?»P}r9À`Mº8=@oyy9µà/¿ür&·zgöI­v2DõÝÝ;"âCßúVüà“ŸÌùX ’GI½æF=±0ÞÝÝÏ<õT|óȤwó‘¼Ö]2=É 2Hd•½1'ONN2êó³Ÿý,^xá…èt:±°°¹,˜v‘A9T삵ÀñeWØkvAÔ!"ÒvØ $¾Ëݰf+¹`-),¢Wϯà@HL®’Yö—’@îýïܹ¿ÿû¿ÿ@ç×/ËõÌ3Ïœ3ó÷Â%T« ®‚K›¯Ÿû^ÕÛÕßW=£S%/¤Un³8D€X÷¬Œ[ÕpÖÍ [ Ù€Êb¹*êYûûûÉØ`’ô‡M²ööÕ¾¨Weè«ßs¿áïÉ®áÒ„u,$Ž›X!Lµ¾Ž8«ÆQÃðŸª@ #ˆáµ)×£®ï^Ù× ª«‚Â2s‚Ì]-é§lgLRneö+ƒJš"ÂTǬÞÛ_ûµê‘[e6}W•" iM†¬Ÿ“À\“ò&ë€ЬïSïe ™wÆÅç­ós\õFãì 2÷°|^Òy•=*úx®Î&À£=ð~®þˆ€±šKSû±Ž‘1ô}FH¸®5åõ§Ž”Æïj_[Ïþ–³ݫɨõªìwÄ™\prr2666boo/™QòÄ@-E¨-˜ßi×pýy—ÏÕ¢"4ÕollÄÈÈé¹µïTžAâèc ,îîîÆÖÖVF;¼[µ Ú>===pœùVåNo4ìÐææf¶¥Þ»~¯®ÙšSAЉ@¸}ûvìîîæœªù9ÆÍx¹ßññqWdJÖ‰>3&5ÇáôFÑ {ƒ¨Pµ½µ/êÞk®ÔýjØ&DDÚþZ†¶¨Ìóëî»ÎÁü=pÕ°dÄ)cƒe©DO¬ÄXÄ™~—ñÁX`Éph¹+K¼«lqxx—.]Ê{c¼ûý~&ö`óúýÓŠBà5„ZA¿EjRÖÉL"`J°À@dÄY2b-Ëhó4#"°ˆ˜Ì`­éMÖÃHh$$½^/e?XÙ„äµ£VC¢98µô…vÐ?/--åçk2)郒kc›×èèè€$Ä^v:d¹Íss566–šÝˆ3À(µÖ¡R×w$ 5‘¯ß?+Sȱ³ê•eÔh7ޤ-5º`>ÉI j•Ì¥ùB’åÔÒÙÙÙdÐ9Ÿþ8¦ùùù\ œ•¥¥¥wU&ÅZ3'¼_•C‘©p,jä©Jì´ lnn.5ôª£ÌÏÏÇÅ‹SâYív;ÇÀߨØpVÌÎhå¤:ªgmkÿÎ;Ùg¢võœcX™U‡ëEDÊ.€ª¹¹¹ØßßO‰É… ÕvÈ*âG?ïÿÚ×â'¿ýÛ)¡Ù¶W^y%íi½5ñØØˆ\ª\‘Å:?9â5ÇE¸ç’$Zccc±¶¶–¹§yIìMuÈ%or Èæfffâãßû^<ùØc1ý‹²£$"ÆD‡Îœ6Ö£££±²²òºÃT!2_5™Û_LjMWZVTÄšo4ñòË/§s]“Rõu« ¥íö{E=-[ûvvvÒ0¿Ø=¤Ë;w2ÿB”ÚçTi[XXˆ‘‘‘¸qãFÎ3•Æ0À¥¥¥LTG,--å=Íß& ί»ë:Ý{äªIQŒ*ƒGnB«ŒE 1 m&ÕT{½^J l®ŒÑÜÜ\jo_}õÕ,Ýg3¢‘‚HOjâ)ƒÈ€J †…Ù#"CŒŒØ°V×ÉŽ•1¦Ål I¡¢UcLëOa~eidàõõõhµZ &kéBºU ¨²I6RíŰñÔ¤?:ožvXY>•=Œ=pQË*ºfff2ÑÐÓ‡ÀÊææf\ºt)vwwXWN’¿;N,..f[$ÎÌÌD§ÓI°l®:‘Ñø*ƒ‰å×_/=ÇwŸˆH9†n?õ±æo kµdErò±v»=ôP®7’É•¢úâæø°3äßý~?ÖÖÖ"â,ErCWÛívSBn4NÏz°99À›>¯ò4ëAŸ4X^^Î5Hû/†–Èêîܹsssù¾UއÝås¼s£ÑˆÕÕÕXXXHiÆÒÒR‚ʪ?–äÍ6_¤(5Šprr’ŽrDÄŸx"~ôøã±¿¿ÛÛÛ™S éT´Œ´Aþ 9”s(""펈©§¥‚Kr k’]¨ò0ïH^ôrœÉ,8Üþ°';;;éøq.œ«ÁžWâddd$Ä'''S‡Í¹²¾ªÍ“øJ6Fò¶¿¿ŸŽÑ<Ñ8̶GðßüfÞ[D†yªpƒ1`ËHî.]º±½½ùD$n¢*쓹Óív³íUO.I\iå7²œ‚)©¹* ÕùGBf DLÜ‹ÓÐëõÒ™p6Y'bkvv6÷ clŽ“ç8¢Vx:¿îÞëÌßZµå 5}aÄYI/,356Ȩ¥»”`ŒÊv»ì´ ǦoÃÄ ï¦DÂÔh4’Í«ѳmöXÞˆH#'üè˜kïÒï÷S˸½½@h¬‰‡•5ÓOªD nn%¬¡$΋/¦Ö™>²nÜ.Œ½Ê=ž-ñ©²íÞ×fƒ¹³!rDܧêgõ` ÈÖä=`B5 cE몉²ªÇ4›ÍN¾¥µ!Š.ÔˆÏÑÑQJ%T|¨ÌÞð|å˜WÉÆÆFÎ5,˜ñ:88Hq–a`íFFFN{ô~5ÁŒ3Ê¡¼fggc}}=×™çe•õÅ”ªPØK.År2+Ñ€V«5òôK$ò7üp_XX¨ôTz@_~öÛº¬ÑsÅATÀªþ<§¦¦²ê -9@nÍqüiûEÛn߾穖þ‹8c°k­vL®ñSæ|îsñ®/})¥ìPÄ ´¥Î }Ùét2s||<žþìgãÃ_ÿz|óHÖætÍÍÍÅØØXÆY#U~Âömoo'å|ÕdjÕQÏz÷J-“Ö|=ŠMU¹@dÏ=G‹ãøÉü þú73ŽËá|]•‡¬MY uØFDFž|ì±hü" cÝÑ¡ûŽH ûÀÎäù‘‘Œ´ˆg•ìp¢íe•l¨‘ŽÖäädFØÖÖÖ’”á ès‡àx¿¹m­ÑÇN§Çǧ‰I.o4N V˜Ó.\ˆN§“vZâ³h¦ªTÖ)Ç`Xv~Ý]Wãÿþ#ç×/ûÕjµ’Q"ÎôòþͨÑaWÐD `×d #VY`1â¬Rßݹs'å 4°l¶À¦„©ª;¯ÉTÚìè“““´Á×j/6X€8"’‘²íãhsòº_›öHrÓÊÊJÌÎÎ&¨ ­I\ú“܈×Fl£~á4ØPlÎÆ‹ƒVµ¨XRÆfjj*£`Ð3ÞX¸ÑÑѬ2£?m˜€\ >Ç3¿0V˜×^¯—ýï€n^èÙûÖÒ–¢•Y3¿#Îòjµœ±©²+ïæ,9KMv´v$s¥4ò’£OsÀ"c”Z­VVÁNN¯Î¡9Ï)¬Ž<' û§ŸD¬ïÏ çø›ƒþ®2¯š MZ%‘S?+‰š¢L@zMœ¯Zn !`,Ù }* g½Öy;\°&šwN÷¬«³];ŠÑ¯mdo€*‡Ô!>ì¾õ^ÇL›HN8/Ú¨fýøøx²í•$ÐÖˆÈHf-XÀ†:0O-|‘(s\»jNöÙû‘ŠÈÅÑ?UÖ!ŠËV²¢ÄÆ¡Jߌy ™S­ƒtªÒ*ºxò@ÑW¶Ó}õa]÷ÆÃžà ©ÍÍÍÌ'p °>O]«¯‰ ˜Ó¢‡æs¯×Ë6˜¿Žõ)‡ÆûDD:uö7Ÿ©¹p8û’ñ:ów÷u^Íæ¸þÓúO•C0NÀ&£Så,ä '''™e)ñ<›‚ÊØ  ‹±«CDdB¢û3^Xîùùùd‘ü®|5ð1¶“““©?ŒˆÔ ’ŠÔUX܆¨o0õ |Ý,kâæ°VWa”i¯^½š¡T,_Mö«É·€V§jX²‘‘‘˜™™‰7¿ùÍÑlžÈCÆx*k„à6m.›ÖÈÈHloogs€C›§ˆˆ>ÒÏ6ý†17_JÀÕ;¸y®0¼9à 婎\ó*ioÀ«Vé0/j JLc­6á(0Yuј¾v»‘}C[ÏœššÊu311‘l[ÄY”Œ“üqXÔÌHSH¿ª,ÈÜ×{{{ÉÌšÞ½ßïÇììllooDÌWó×:ÚÙÙI©„÷¤Ý•OÓl6cuu5ŽŽŽò¾ä8ôüdÆààà Z›qÅHΩúöÕùÅþ÷ûýxñêÕøð·¿o{Σê×ó,¦¦¦rGDرõ·¿=>ðÍoF÷ïÌÄô‹9É‘2ßÕf·¾*A¡Ï81*|ŽŽfä û̹Åxooo$6×dI¬=p "j"^OÞ :ö÷÷ãCßúV|÷cKéîÚívF I‡"b ¢*é¾×ëebì'ðƒøö‡?œû‚ïY£ÆÁ$úRuììŒ9Àéu-¶–%H#AjÞ牓ÕëõòÜ©©©èõz±ººÇÇÇqùòåxõÕW¢oœ^N·õèþaˆåååŒlV['Òê\—ªï稘ûÚÀ>ػ쯑»Ïþóo ί_ê뼚Í=rYà »2cŒ fT‰‰&`È`ÖJ5i[ǰ1ìÍZ­ÖÓ+‰«26U—Lÿ777—Z[ÌŒð/`Ú,Õ›Æ>騪5ÆHÏ~ÇWP-G€ƒáïf@ásÏ=—ýI+xnn.C͈ˆÔŽ=5á‹.ÓæÏ¨Àœ2 L?ÙŠ±¬Ñ!cýA›\À HÀ#"ë¸ë›\=9´JI°¢U–…•3/¹V«5À,bé¼·~vÇ“Ät»Ý˜ÝÝÝ”=xs´ßïgùFÊÈ;ÄØ5?""õÖœ}«f·Mwii)S•–Ô\2‚š£qtt”ëCG†Õív³Ä¥÷ñ]ïÆçÈ% ÉÙ³¶9ÂÞgbb"%´Ùtïú…s‚y¯ §æÊ•+Wr͉RLLLÄúúz4§cÍÏÏ'HTÚSĤ@_DdDgqq1A óää$e(’ß#"O¦»ü8jµ„éÑÑQÊتÃÃÓ²¹÷»¿ïüã?Ž~êSqñâÅ´[N³õå˜xö\…ý5­%e½' »½½çnHÀf.€ñÁÁA–|ÑTqJôð5öŸ}úéø‹|$š¿x Ø=u||œÇÔ\\\\L}:y'cmm-ï+”ãÅ®q,|Ïü¾xñb\¼x1Úív&£š÷æ_«ÕÊñåÖýDÒvtt‹‹‹i WWWc?wÚÚÚJæŸíaß'&&r,jTvttozÓ›âï|güìg?‹Ÿþô§ï$¹½ÚMëÕ^£]l±v™×[[[éˆxæùu÷^ç2›{ä@yñõßµ„VÄ©‘Pxø6îˆH=t5ìØ?W íUÆrø¾þ®zl?³z.PTÁŒ«–[«2ŽúÿˆÁg„TæÚf® µõ?ú°–6«ì€[vˆ:Þ‡ÞÓXÁõþ%­³&Óv«[M£¬_/ÆS´¢²ªú¨ê©%HWªŠKjËGœÕÏ&®íM S%sss©—Ö‹ÛÄ95’œI~FFN«“Ðöb «AD¡ßïg‚†$¤Ñ8=ã·¼¼<°f"N^Í}±½R׊wžžŽÍ66±æIXïÀS-Áq¦Ÿ6o±•À"Pcþ‹:Eœ%zòAŒ%ûwpp»»»±ñ+¿|â‰h¿ãù,ò `ˆü†ì¢iÕ¬Ÿ?÷=ÿ|Ü÷ÜsñÚ›Þ”}Ž¡U^W$¢&Dc_«.þþûïˆ3’¢æŸÔ{ˆ¹…áÖœ„º¦]ÇÇÇ177—ù5êðÑï|'""¾öÞ÷&3MRF"iýŽ.\ÈSQ%¹’ŒH|þèw¾ßxÿûó=šÍS)¢ýDG ÜÆŽí™ššŠ+W®Ä'>ñ‰øà?=ôPÌÎÎÆ7Ò¶êÏÐäuge—Íi¶»ßïç¬N¼u±¹¹™IÛ››©"‘±ŽÆÆÆòDhöÝ^ö /¤Üjbb"Ùýf³™sCõ(ÙÉÉI®gö®Î©Ú®fóT†ißüÝßýÝÿ=Ðp~ýR]ç2›{äªË`l”†cœjâ `eŠ8«Q“”¢‹8Ó±K¼páBÖ¾sçN,-- €«ª¼páB,--%ˆ8;à¢ÑhÄââb¬­­å÷hj•WSþq¸$Hß)yˆ¡8«|¬–ßѶV àUö ZŸIoZ“2#¶²–°hc›+йØ[“:%wÕj<(µ±ONN¬ÊÞ="²¶ñÞÞ^‚À_¸[_ïííe Bs‚s#L홀+§ooo/e$€ˆvíúÈF*‰¸œ˜˜ˆëׯ|ÖÖÀçà#cRbc¢2Íòòrþ(µÉïïï§T¦Óé TLÚÞÞÎr›tãôïÎ+ÀÌ®¯¯gŵõd¾ët4÷F#æçç3YÖ¼Ð*jÈwPIŽÔÐ5sÎ8€C¶<§Óé¤c{ùòå?å777c~~>ç8YJMv@Œ[¯×Ëx°´Ö”9ºµµ•’«š[Á1ÀnZ#¤hú$ƒ6[¾MD¤,‚smÝŽyw•jŒGM‹ŸýÎïÄÛþëÍäþ™™™¬fÂ>r96lÀÊö:y–ît:qß}÷EÄ™SÃŽ_¸p!+Jq±Å`b“Ømލ6×g͉ˆˆ¿øÈGbª$*×JNÕžV[ų…ʲª¨YÂ’À–Dœ:u½^/mG2==—/_Ž÷¼ç=ÙGoyË[âÉ'ŸLɸ™Ÿýþiívë!ÀI0ÿÔÊßÞÞN'EáD¤@­V+¥<ò äx6ÙY¿ßOi!ÂŒCh/% ­gIØ+8¯ª¿±¥5²dÝEDÊϯ»÷:gæïëßÿûŸúm†Ü"r1B’|°UM¯NwPa}¶Ùl¦¾½&Xad6#zxx8PéæMR€"L¶L…,vö'''eþÜÓ&ÏIðnÞ|—sƒ5e¼Õ ¯Ce]@Ƽ2ìÚ#I³êø'''Ûô1yÀMwÝàm~grÚÐF£‘ÉÂ5‹Æ¾—ˆˆû~¿Ÿ›ae[ELÆÆNk×w»Ý|}hÜCíòË—/ç3ÍQmêõz©®ÕKH0Õ1P.²ÑhÄÊÊJ,//çw777óÝ+C^e66T «wŽ>ÕœãããY‚Ñý•÷Þ€€*)ÀPË ¨àźކ«B™«ÜÈÈHžù`óçHŠ8Õ ÍU¸[ IDAT†ONLdÇÇDZ¾¾ž,¥DcY“˜±[[[Ñívcww7çuTÉG§Ó‰+W®dDÇ´N§§§£Õj äÊ ·ÅšY[[¨ _õõúÆX´åWâú§qóÍoÎñƔפq‘%Ñ N¶¿¿Ÿí=wß}ñ‰ï?ºïzWJÚØ3ù@—±Ðò#BÌs¬¸qeoiÃ9Žúgll,ºÝnjÒ/g{~~>m*'ÑùÀ7¿ßÿÄ'ÒÁ0/jå}&‚ѯQX¹rW>õÃÆ_þú¯§];=¥Õ²ÞØåa'}mm-xà¸téR,..æ¾qûöíxñÅã•W^ØŸØO÷`'nÇ–ONN¦óo¯&fgg³ÈŸäTdLDäù‡‡‡ÙG˜÷JbpBk#J8UËoÏñNzµ¯FÆØ2јóØ»ó:gæï¡‹ÑŒZÀ¦Î¸Wö:bPó øûŒÒ]usðõz½4ʘG QMΪÿ¯LL­(Õ ØCÿ¯ì—Š0œ™š0VjI€¨:-…W16 t6ßjœ9\W ,1Îfh´QêïùùùJ€ðÊAð³*(ž‰y®õÞ@ãˆÖòbŽi7"rÓñ9m©‡¨p j²_EÀoÄÓZ™K2ýÆùS¯Ùï¼69"ÒayÛÛÞKKKñ·û·Ñëõòs>‹­Î=ß»`’IŸ8 ZÀrvv67iÒ¨Z\Y:Àãäéw`W›­‰*eªŽT•N`ä\Ò5¬µ¹íYælMŠ­‘4 ÈÆâðð0¥M4Ì`D $õrÄI‘8ýÆÎT§hx~‘Ò9؉c&‘Ö|Q¥‡tÉQ 61âÔù#?³¬$„qÀÂsL«.žÃõäcÅ¿ü刈ø«O:íÜèèh²¼5 èÞ"næ€uRZ¯×ŽˆÌ°cl]%mضºX#æGõcßýnDD|磱BÆpŽjÍx2.ɹˆOMMeýþšPn\ÙÂÉÉÉdäýPe­’½ÍÍÍX[[KÛµ··¯½öZ²×Ö¦qÊ9QìU-òPûǾSïÑétH#ß×&{`»ÝÎ*lö-2SkÂÚ©2+ÒVû¡õêð=‘-m1OI—:N’$Þ}ww7÷¢óëî½Î™ù{àú⿘ ÞôÖp/9EÕobš*Ã\ÔÍ f˜„õE0½@'àM‹Œ!´Ú„1‹tÀX& Ö&gƒ²Ù3ØxSL/P!*`C¡Ó­¡b€‚3AžaórÐÖjœ…ìm6lšU§ºOÔeÀyŠd=aY|•>U=6G °§ ­ÚT¬Ð|V ˆ cll,7Qaß‹/Æêêj–'TYÇ&,‘SÊÀ˜¹ ŒV@ƒÙUr-"²’LMˆ+W®Ä£>ÿê_ý«øð‡?œŒñîîn‚"kwº-Ð+Ï¢jÝå?,,,$ƒ ˜ˆ9£6·§¦¦LºßááaVo9Éd(€ƒ¨Žç™¯ÞÏš­•8+æ•u@Æ€yt/,#' °˜žžNG¨å¬Õ¼ÏñÞ*2aDk%,óxcc#¨ïv»)Yªò!¶ILR¶ˆ`ƒ—ÚålLdww7~~ÿýñþo|#n¾éM1;;›gR`t­yãf|9 ¢l]ù‹<¼øb\ýùÏã֛ߜ}ÊžÔj5Ö¦1¨s a€XÐ,8­ÿââb²²4Û˜]¹9ö4"ds¿þ—ßxÿûs¬"NåBˆ6ËÁcì3 ,ÐΈHÒå£ßùN<ùØc©·¯Í.]º”¬¾}Evww7çéññqlmmÅúúzlnnÆÎÎN<óÌ3ñ /Ä+¯¼/^ÌÒ¡YÎ!ðî”iÅúý~J*Ùiã­Ò’µË¾š»"ÖJÐÖ(0[.𡤍¹||<#fMUIª}AyØê|‘q$a³³³Yц=ü¾ðÿHœ_ÿh¯gžyæÌß ×þá0å lMø™œœLÖ*âŒávª&c€y©!ê£ÆD2ŽŒ¤EoÝ|±TU§«¬$cæ¾1 ÁÆòÕrXušX2„ªi""Yw€Ä=§F2’§'úÙ´`çXØ4 Ôa+ msÄà&‘‰MÀÈææf2¬že ""ßCK[é}«Ö[¦€†ºk[¿ßÏÚÒ˜È*C2>€­UDsÌC¬6çjgg'çýxeÆÜÛµ¸¸8 íÅtMLLD·ÛÍ1ÄFÏÌÌÄÛÞö¶¸xñb<ûì³ñÊ+¯Ä‹/¾˜óâèè(ë¬÷ûý žÍ¡¸}ûvö!gÄØ4ÔÚŠbˆ aÅ8mƉó¢D_€ùK—. %U€èt#"­õ¨Ï¬kk»&9®¯¯gôÁZ!pWC÷«²Ž~´iîr8æ%‘œ›“““< UŸ°)ÎÃÃÃŒ¢¬¯¯'9Á¤uM­2]7@,T5ðæÌÞÞ^ñDDD|ëCÊyಘeóÕÜg´mbb"0l÷‡¿ýíˆ8­ËÁ¯$CË1ª„ŽL¥ÙlF»Ý޵µµ,—êžÄN§{{{±¼¼œvxss3¥_•à@°\¼x1íþÔÔTJòìŸÖ @ÍÙó~ì6Ò¢Ê8Iª¬u’'ï\ׯyf®W ÇŽóŒ(ÛÛÛ(Ë,÷øø8~çw~ç ÂùõK~ƒù{äú⿘É0׈3©KeAyô9Ƥß?=äFâ`V“m¤ÂŒ© »nž@NÄ£m¯ºà T}†q®•p$¯Õ¤&a뺙€–̓ÚÖl6Nkeô…‰±—5 >\žÐ;`{jÔAˆÚ½lb•±§;ôlxõôÇÊ0‘DpZD!l/‡‚ÆKí"Œ]½:Nj`«äëI–òÚk¯Å³Ï>ׯ_ëׯ'›N㎑&Sª›³gÎÍÍÅÄÄDÌÍÍenAÄÙiÊœIlk²u^WgQÒ¬(1ªŒ5À°³³“e AÚqgDXgÖdRãëHœÃŒÌ7΃ßqtÍ߉‰‰¸uëV&‹?¢%²îªóéªeT{ÃipóB ÉÓ&ŸµŽ1ºl‹ £½³³‹‹‹1==/>ð@Üÿ ±þ¶· 8æ[[[9w1ÑlAöU}='Q›Ößþöè¼ãñ¾¯=þny9“A1ðÅÅÅ”íììÄÚÚZZë±&Û›ãõto§W;0??ŸQ­*±IØÙÙ‰ûÛñôg?7~8îþþi¥³•••´7ê§›Û›››iï§§§cww7sH"TWž{.¾úîwg´ˆ-©ò,ÑNºp‡‘yã½¹¹'''™°ï}½g«Õ ND…Ø¥¬å+©e3çj^”ˆ¨ýJ¿s¾$™[GG§5ë9žct»ÝXÍI# e U¥b÷\H'ç[è»ñ/þÅ??œ_ÿø¯gžyæ¼Îü½rUyÕ Zµü™–…‘‹¬-]«À¸†tø™ûTݾŸy´çzO0âÌðžõgÊ=VùKmW½€Ÿ©×ðçë» ¿~†ãSÿx'c¢}Œ0§¡þœS¢m5ÑÑutt”ß*ô{í_ÿW£ÛÏÝÏg*óî3þ­-Ã`^ŸWÛãß®7ªqí³äBž«Ì§öW){Ô9#´îÚÛÛ‹ëׯÇÏ~ö³¸~ýú@ŸV'Ä¢~ߦ¿¸¸˜÷«s¾ÙlÌql°ûÖkxnÙ€«¤Æµöíìì¤üÄ|¨ýZ«ÐÔ¾­9ƒõÔëò}í´f8³îUIòµª¹®í¯mòìÚçµïÌ gø]M.7&î%‚â÷®Î+'·Ú¤I•>ÿ«O:~õË_h³vº—êZÔçÚR«釽½½øÉoÿv|âûßw}éK}§­ÕvU‚ÀX²}µ?ÞÈë7sº&¾Û}ë[ñÙ§ŸŽïâ)שóÈúñ•°ªþÝóŒ;^ÇëŸ|å+ñ­}(5?žCužúŒ«ž`ê?íb½ƒgÕòžJÁº†í¡çÖwªïRmcÝGµ­>ËóëyNâ­m¨—6j“ûmll ظJ Ï%ót Fýùuw^ç °÷ÀU}Õ€Ó=c‡±$ôÄBXz¬¦www7õŽ•I§w·`|ÝCHŸÑÅäaV±Jõ$½Êt*†™Šˆ,§H–c“¦qVyfss3FꦊAê¬FyZ&Îû*Ë×n·Sæ€Uªú[Lýììl¶1"’…ÁÌÓÞcKig«îXèËSñ;›z£Ñˆv»ìfMÔ¬Qc^õ½Âá˜29ºØI›ÉE-§æY À+£e¾b°¼»¾¯ydæåþþ~´ÛíœÃ6DsÐs:p«ÕŠØÚÚJb®IB¬ÌX·ÛMvt||<æææ€ˆèFvvv6Y2,3ín• Ôdؽ½½dŠ}·ÛM†Ýú‰8HÈ ¹sçN–¿Äêc•…óEŸŽcii)Ôááaž£ ÚæÈŸ*(!¯ÁÒp»·µemJ6^YYÉ÷ñ¬µµµ”A‘ µZ­”Yëš;ä8Љ"‰ÓבIáN½6wµåÊ•+Ù‡’-#"~õË_ŽÿùùÏg»vŒŒŒÄÜÜ\llläiÁ‘²;L0Ùˆ Äááa<õ™ÏD³ÙŒõ«ñì¾2›µµµhµZY·üþûïÏqð3ò# ÈÖDu(éµÙ}ùìÍÖÖV|ü{ß‹ˆˆÿþOÿéi²ýÖVÚH}®Ò y(®*FF#YdÏ®IáJ^zVÈ¿Ý5w†#\.óÜÕúÍÍÍÔôÈö©­­­µQ4©–SskÁ‚š/555•e='&&²ü2M½(ÚØØX–PÝßßÏ"Øö“““”ì‘•²³³³yhš}±Ñ8­ô»páB&›g${Ífsü¿‰u~Ý=×¹Ìæ¸þí¿ý·LG­t@ÿ\3£££)CÀ.U9GÝ0$,*‘l ã‡ÉU¿*) ¯gŒkÕÊÄx?Úi ·C€üøø8 >]fD $ç1œ¤F#­ªl[eŽŽrÔOdHýþY)CzI@B¿’è;›~M\­I{@MÍQ¨e µ¹Ûí&x¥mÎÕŸBÖdÀµþˆd2kífŽ•Ã†j•Ž:fu™g•]¶¹c¦ª€#éhr`|N?ÓL·Z­t"½[Ä™¶5"2dNc\LŽ\Õá›—æcMîÓ.å«£U“²&Žåœ£…•Ì À¤*$]œRÚúv»²‹ˆHi'€ã äU T“ɵùèè(Úíö€S_ËšÖ¨ž9á| •ˆˆ………ÄÕZA  ÛÚÚ¨èb¾xd2úG©CÚi¥OGFF¢Ûíæ9€¨äîn·›=ÕÚÜ;#"ž¿ï¾xðå—ãÕG±±±xå•WÒn™«7oÞŒ•••d>ïûú×ãÁë×ã™ßøØxûÛ³MHYDa€À0§ûý~:ÍäLô÷Ê›¶Z­xë[ß?úQ¼ô/ÿeö±ïèdL¢qu?899‰õõõ´±•g$ ל'’3„±:¦l ÛD†CBD’¥ôgJìííåçí'’›;NæO ˆŒ«}áSí²±cS«LŒ“RÉÏîõzùžö•J¸ýÞïýÞÿf8¿~¹®óÒ”÷ÈU«kDœÕ:ÇzU}9Íl³ÙLã­: àÀ1ŒÄ/›KDdNÕ13èŒ!#ØӘ݈H ²“ƒ¬F«n6"FT˜î¸fŒµ§ÕjE¯×K¹D=œƒt£RÁàFº ù¶&@¿Æ¢JGRK©艪’¶ö÷÷sC¬_Ö¼?Ó?@Àå}Í £ m6›qõêÕ˜×^{-7~Yà¿6ìFX–T+ÙØ`Í‘Ÿˆ³“`FΩÍÎçI>”ëÛÝÝMý, AKʬ‰h6y'RúY ¹W€à½ê†©Ÿ•Sb³Öª>UPßh4¢Õj½áÙ €PÄ ¤)"S«Îˆ>¶fZ6¢ß?+ƒ:22’ºeLºC‰z½Þ@H-ïˆeìˆ3yG©&Ó÷z½VµÓéä3k)À ¼ˆeþšKc¶ÇÜ1ïj4¨:ld&ßýØÇâã_ùJ<ó¿U‰D\5§§Jú"Ϊ•˜c@3–ûøø8žúÌg¢ßïLJ¾ùͼçßü³ûûû™—¡oÔšøX“Eaj5¡F£=ùdÞû¯ó7Oí}œCºêêd[»Ã’Ëz ïéwŽŒç·Z­h}ñ‹ñÖÿüŸcò¥—bcc#zöA"ìèèi¢8@?22’`uyy9ïšÌé‹8«Ðµ¾¾žã¡jþL%¼{eµ+!¢ ~Q1È^S#G@¹¼û“H¤½°{ÙÌÍÍÍÌ}ñ5¯†cÎÞT /âå7ŠDœ_wßuÎÌß×ýÑ%#½³³“Òˆ³ÍÕÆ˜üå;˜ÿo6›Yƒ—fÕ½çææb~~>:ÎSM¯¹i·6ËÊc¢m:²Ð7p-á¶Ýnç¦W«iøœ£”ŒŽŽ€•F£‘•*Àæõ~@.ãZÃþ¤‘U/€mUn,|* J¤O9Z3V«•àºu `‘›¿ ðD:¸HÖ%³™™™‰k×®Åý÷ß7oÞŒˆSVˆìETÈËÞØ=N  Ä>$ Þ·‚üˆÈ<I­¬a•àjŽÛx}¿‚uÏ©U‡Èš*›Íôž@^eÒú{Ž,)ðëwäDp¤°áF#666b~~>“¥I""Ùnåµ{}õêÕt¶9ðÀÌÚÚZöï0(]\\ÌþRNB0??Ÿ z·nÝJÐŒֹqê8Õ„ó………RÖ©¹i½Yó€d-oˆ•]ZZŠˆÈÊHsssù<óTN'ÌZåˆl¿ûÝñO¾ò•Øyï{3ÂX-,,D§ÓÉ>¡`79a£££ñÚk¯%ð«m`±³«oyK¼üàƒqû­owõ«qõç?û_x!îÿùÏãÆC Tþ’à©mæˆÃcO>÷¿ðBÜ÷üóñÀK/Å·?üáØ|×»â¹ûîËèÈÖÖVìì줣¤Wùe¶ÕêEœ`6`® ¨###ñ®/})øÃ?Œ+W®D§Ó‰[·ne9ÀûûÛI®É†pFFF²‚“öZ ú˜½VÕ ¤ÿ(¨R(åWÍ£ããã×É©ê¾ÉÞ8¹ÖúªïÄžø<9TÏ‚!%·a¯õ+Ǽ²õÀ¾ MÚ% ]ÄÏy5›»ó:gæï‘ËA8‘eà"""€5???Àà©‹K `3Æ^0˜“““ º„ÿˆHÐ ”0RÀT½*Û¸UV R‚t² &pss3KabMEý ê­<Ö6"òsäDU/ztt4PÙÃ999qåÊ•|/¡èZʰW†™3¡ôXBÔJMùzB-ù‹þSÂÓxxxZ“žŒÛ…¡ɱ!½ÁÕC¢ô9‡áÖ­[ñÊ+¯ÄîînÎ12‡hjj*Ù$@ ô¾8¬“5÷u"L» ÜÆV+ò èyÍ9‘ Léääd,,,DÄYB¬œù$´¼ÉZ%Æ:=­…k·ÛYõÇÏZ­V²lØ´Z ÒóD %-^uxx˜eMë¼§ÿ×.cX#VSSSqûöíÉÄÞ .$+*á—³'BKŽ'»téR®™Ú'ñ±±±ü*5ªŽ;Æ^ßš'@ ÛCÿÚk¯Å;wòTSåXÉcª=³Î)RÂûpÄ$D¾ãOþ$þêÓŸŽ£££L&ív»1???àÉ0ïä:Üwß}Ñï÷sÌkb±5C¦Å¾ýèñÇ LJþËùÙüï}üãiGšÍfLÆY SrBžœœ$ _]]͵¼¼¼œ'êŠ:Ywη˜Íû’1)CùôÓOÇO~ò“xõÕW£ÛíæšDœˆÀDDVj’ÀqVèãkŽG¿z˜“ˆ¥yÃ.²—‘Î BËž€¼ˆ8%[”í”GqVݬæˆXթƶ“7ÚgäÕØGjžb@ÞE=¥Sßjµ²¤o„yDGR¿X—*þœ_wçuæïKȳp¢0c5œìV*Ôª5Žˆ4°kkk bȳ*5ä³³³¹™æX8l6ý¦d ÔfRKøÕ¨Vyy9ÀÑÑQôz½>¤CÕ¸9ø$Ðn†éééL¶b|yÓUãÀŸ•\#I²ii“ÃIÒið,Àt~~>+Hp€­Û·o„VõoÄ™N´–Ú3&µRŠäPŽÄØØXVI ÙHhãÖ­[™´\1€ÀÏÆÇON±ö,s~çÎèv»I^•¡Í{ùÛüªÏ6Æ“““qé񴆿«tFÙLjw333±¾¾>P1åÂ… Yö·æ<`mæäFa‹µµµt|8SXDm³~%ʘ;wÌaA‘ òÅ‹caaa`mÕÜŒ~¿Ÿ'êšK@WÏ6ÍkŽwÕöZ;­V+¶¶¶Ò ㈛ŸÖ R«Å`ý–ëׯÇòòr®5ë”>Þ˜¸¯~[\\L€/ 7999Pã½æ!4ø«O:>ðÍoƾùÍ”Ãôûý<íæÐpî»ï¾t@""­¹¹¹X^^Î±ÜØØˆŠVÙ‡àï’&Æ,"ÈY oÿ‰Æ>W«Š5ÌÝðìVc»¿¿N'Çÿððô„cíçÄ Ø‚Oþàqz‚ìøÏžïÈ>{^=, #Í6^¸p!÷Šú»‰‰Óƒà¤Vô1Ôœ„šb>‹8ˆg”÷àà ÷¥íÊi’!g*YÀ™®e%‡O·‡É[³µµ•%\Éùö÷÷s½i¿}.â4rÆöŸæ—Ôh¨½…í9¿îÞë¼4å=tU]iÕ×VMó°œ!ö= ŽPÒŸÄœa}ž¤VúsÏs?†ªê3‡/€¹–¯¬šdŸ©¥Ú¼‹ª U;X%>5ãßgêÆ  ÛjßÕï`„½§°¨2dõª%*ë»øw­9ïÝ"ÎJ¡ý¯Æ®~6"ró­÷Öϵ/j9¾z™7uø7v´Vª~,”÷3þž§µ°Vþͨý…Ù¢þWs¦ö§yXûß3€2ï_/¬¬ßYoÔ_õ3¢Yµô\ÕØ×ïûùôôt,..ŒUmO}®qÓ_ ê8pBišëï«TÈ\šMið­¨}f.Ô{hkÕWgXYHcáûœ¡:ÎJ…º¹†á®—wó^œ¸úžu^EDÊkÙF…wøÑãGDįýùŸç÷D,äzÏú~³³³Ù®V«•ŸWSH}ä{u]r²Èë5<6æñäädFÂ|Ž=±nßh\«m1†µ_õ“ EÚë÷“““ ä¿÷ñg?Ö5jî“t@úý{ùF6Ùó6*ùþ2lß°ÝÃ<¯sIÿ­¬¬Äµk×bee%ÇË:«¶>"âöíÛqûöíו¾åŠ8÷+++ïÙZÕ/æ¿çŒŽŽÆÂÂÂÀúŒˆÜOvvv¢ÝnGÞ‹½é¨väüºû®sÍü=pýÁüÁ»\KÏ‘Mؘ$ V1†ƒƒEg8… ë& ¹´§jر¸Œ¼7I­0™ßÑ bF$Ybi„)1"˜V¬Æôôt2yý~?OŒˆüœ››Ëð¬v’)`3U®ÙÞÞθª!ÆÒø9–ƒSðÚÚZ2®>Lh3ÆÍ;›'ú×}1AÂɵº gSm`ì}îððpà QŸEœ²‘˜E ÔÖÖÖÀ<’´¨ÿ¼Ÿ‘ŽZ†ôÊû.--Å;wbww7Ö××S+l~ÔµÑjµrmÕ‚r8ôyDdb£9¥d#À¤½¤ÀcDÄÚÚZ~ÀÐ}t||œc€¡— aÝbË9ƺFº”ÊóŒ*‹êt:9^SSSÑétbcc#OÚìv»éÔ‰6Wœ}j·ÛÉøW6~{{;vvvâðð05Ì@ÙLºØzy)ãããAØß?-Èøã°<6ƒn|ww7ÚïxGÜ÷üóqùÙgã¥H€X£Y*± …0N‚œ  ›­˜®ý€ù_eXTײ€uÏcoä…DD&Åïîîæ¡`ôë½^o 2ÛFSn}‰éëˆS€üÑï|'""þò×=‰Ÿïv»9÷Ìk}m^Ôu(‚£Í DDL%2JÞ‰ùî÷Oå.\H©×ööv®Ñaùd£££qùòåøä'?ŸúÔ§bgg'žþùtä(·ñññdîEN›½‰4ÒÞI2'™Yu"û{o^ˆ†“{rVjžÕØØX¶ibb"£æ{òùÏþÿ’8¿þ±^àÞ¢ IDATç'ÀÞ#׿øÅÜèÛívjŸÉ+èp…=2íÂ… ©_æ$úÔ“^«,€ìƒ¤"Înku ÕûŒ¤ÚÁ6~÷f\mN´É ÕËÚxI2TCaONN2^}#Θ$íž¶9+Î8ÚˆH„i/{D$(©rΆ1#P€<àQÓEW†xq_ý[K0V9EeÄjI5¡lc4 ' ½c(·¶¶ª’ЬÓòJrjlóC%§;Å"J%À8“q˜§àF;L~Á!ÒÇ@Lm_•pn0ŒdÆŸó¡Mä_À”ç‹‘û½^/Á³A9Âòr0hå€âðð´~9 á]$/r€í1Gõs­¬‚eä u»Ýtàµ]b2öøøx¼ë]ïŠG}4ËFª Ê­Ÿ^¯»»»9kÉOŒuÖétÒ9fµ«í3¾ÛÛÛ177—åõÛÄÄD¼òÈ#qÿÏ×^z)ž_YÉDNýWíI¿ßv»=PžW¢)ýôîîn>¯ÛífŸ‹DÑmë{ë›_Ä­O ˜¼9lb|c äUÛYÞÜÜLÒ€Œ©*P¢•~›Fþ‡ŸúTôz½$MØ¡ƒƒƒ<_¢®›ºön;22’qœÀ¾‹R™#kgaa!m‰9e.ZÖ¾œ@zff&¶¶¶buu5VWW?í5G«µ•5çççãàà ê?úÑF³ÙÌœ$‰œ¶áŠYÊo"=õ©©©XXXÈShµAßWùçñññyiÊ»ô:ó÷ÈõþÃH¦ill,«šm’L€‹ÄêØl|`¶Ùa996p -=1à\X›ŠMÐ`\+ûôôŒ©Í(±yËôçÚ‡ÕÀ*(¤—â±66Fãìp¬v»‘@šÎ×çÝ[¦35§¤&VI Ô{LŽÍ£jŽ#Î4ßgZkRu䳉‰‰déª~¸«’ ì&¦."RË[Ç sÜl6³b ‡Dµ šêýèC1ÙÚRõ´•æwgg'Y檓ö<@ûèg怤>ýWçä™óÞ‹Ö¨J'µPeÂÜÔU ‰8hœ¢š'677— ç’¾X;< ”\96vZ#ûÁŒw¿ûÝñàƒÆÒÒR2¦Ž«¯óŒsÌqÁ×Úç˜Aß=88H ÅÁ¶¦±×¥ã”ݸq#±¤>s{ss3_www£ÕjÅÈÈH,,,$?<<ÌTó6"bnn.£f1°æ3ë²JÃä qº9·¼ݸ×^z)Vßò–”ÒI¤®M¦§§cnn.ú1·Íiãk\8_ããã™”¬=Ö§Ï{”œHÌÑÑQVìackÒ5ÇÊ<Š8Óß[ûl.F¸&mrÊ|ïƒO<?züñÜgDµ©F4储²†,2ßIFê˜{æòÞÞéPúœfÃѬr#‰ø*¹è)Çùðð0^}õÕŒ® )¬YŽ1€-‡…mÖ?¢yœ8ãÑh4âöíÛ¹¦Œ…¨§˜=CF)qÙn·ãðð0®^½šc«Ÿjä4âÌa=99‰ßÿýßÿã‡óëÿõÌ3Ïœkæï•  ªÑLŒ ÇfWõ­*—¸§ê6< ÒÆ€·™ k ¹¿#ΘyrÄ™þ–ÑóuÝ}ÖwkòaM€ª%3=Ïçï­­­,ÛVõ»*xè#›¬MU›8:èz>ÇBxÐÖâ3â5QûÈlƒ%Ÿ¨ÚWì—(‡Hˆ°·w©É‹BÔîQÙ<,«6ú ©‡¶«ª{•̆vgò™q•Xˆi4~ÆáÎ;)ñІá¹TçSŸñÚQ« Ë•ô•¯øy=Àjø;î ä×äF, |||Z¬ qļhY=GakkkTÏ…ÁõŽæÃØØX,--ŵkײD…ŽS²&*CêT“úüáhgäëÌfTŒie:N¼ôÒKö@uɉµd& “{Õ±¨öÅ©$ËVY—ðJJÇDÓæõØØXüù¯ýZDD¼÷k_K§^ÚØx‡ .Äüüü€¾Üýùzª©uh-’ˆTçÒºáìÔ$VÀ8âL'_e:*¯T;Ôétboo/677`¶5²Pû­9>>Ž÷}ýëqÊÈ÷¿uhü1áÖªÓT!2ÞœbäûÂî*(Àé¬ëÜšš˜˜ˆk×®%ËÎöØ EÍúý~ÊUŒy¯×ËÈŠµl¾×9RežÆÏœ"­)müùÏ> ­Í®¶}•$q©5G666¢Óé䜨¶ä‘ƒV+Ì_wßu^Íæ¸0 ­S§§§cmm-Á9Ó&N;o3ÄzÔÚ¼Øc´›Ífn¾6šHÙºÜZ͆À±ñ3΂ª46áÅú@kll,Rë 4…’<íiµZùî~¯ìœû`üm"#§6b]“‘E¨Õ}TT8>>=Nð`@•,³é›[·nÅC=1ˆ½?&7"HØ °ÏúGøXnƒ¹¤zÊøøxt:==ôd{{;ÙA¦Íess3¶¶¶2ÌûêìÏ‹`œœœd% Îg¬öWÕ%ŒŒ¤Ì˪lœ÷¥¥¥tfm~1ÀŠ“Q‘PŒÇÆÆF&&ê Žfybb"’©sYTË<µn^y啸ÿþû#"ÒIäTŽŽŽÆ72]˶’.U'éää$6773¶½½/½ôR¬­­e©@R·ˆH‡öää$vvv²bÆþþ~ÌÍÍelfoo/‡ãããdÎwwws®š¿œ¢£££¸qãF¬®®æÚb£ª£ìžRÌ¿(9U(jgýêΤ³³³97Ù¼YaÍý*ÁøŸüdLMMÅ»¿ò•xö _ÐñÓç[Wív;çm-‹h.ãf³™ïeí9Q—ã"RwxxiïFžþZóN§“‘U8Íf3µÕûûguÍ±ÈÆ—³BŽth6›ññï}/¾û±F—~Ñ—NM8«‘Î!²¦¬%6Ú²‡p2–——s-½Æœɼ¨šÅÅÅøÜç>ÓÓÓñõ¯=ÚívÖiŸ¥¥¥d¼kQD¤m«ªþܺ:<<ÌÄXëµ:3ÆÎÅ!4~Ö„³(ÔÄŸ››ˆ‹°þõdkDOݧÉÝH¦DeUQ;¿îÎë\fs\ôG4 TkR°[½ú£££¬W Ð1VSSSith«>p©ešçª¯Æ “bÔD!DÀ2"rîɅu“W~Φ"ùЈ8cöl.µ69¦óèè(;ƒÊ ßÚ\"b@Û[µú@`Àá©2  fµ—Æ;ÖðxÍy¨Úvõö½ ­»”SM2ƒ•®‘“ÉÉÉXZZJ@ˆ±¥s70²žAÇK:cƒÑÏÀšñ%§Ð~·`eSÇGœ‚%×ô¯±UÏsű1ôÃÁÁAÎ É  sšZ¥:E(°ŽõpŸf³ùºPeÌjÝõV«•Ž*ða³®}W%?¤êS“£pÜD1¦¦¦2ç¡ÛíÆ«¯¾šù0Þc©ê çM‡9â=8Ævkk+e=ú¸Ûíæg”¬ë¾æEaÛõ-ÆÔœ‹8“’‘µÕH oŠL! 8ßî!1Ñö…óH‚-ñêÕxÏŸýY<ðÒKqû­oM®ÓéÄììl,RkÄÙ nÍR5ý±³³“6Xe"’üÉá4V# @íÝÝ ^ZZŠééé°úöÎ;y(ßÄÄD,,,ÄGþâ/âÁë×ãŸüdFzÍYí&Á$…Ž."+ª-Ñ.mÍÍÍ\Óæ¢µS#^{Õîîn<ûì³y¨]¢Šfu»ÝçÓä Ô±¹#Ë™œœŒn·;uc»Ø íÐ^6×ÏüÜúHîЧºö9>¤Ž´=à²Ã51öøøøüШ»ô:—ÙÜ#`ðÕàp9BÌ&âîåóîèÖpz½Tè`l½CeDl¢6¾-‹Y˞Ɉˆ7lWý}}¿«cåê3½O= Œ¦õ\,ãðœ¨r½ð»Ïj³r—/_`tµO¿Ô¾ñÐÎæxFíûá’põýZ­ÖëæVž½‰™çH4ó½ZZ®Ž³³¾Ðr?ÓoÚ=Ü/ÖRgŸÙÙÙ`M%QÖqwmllÄÆÆF´ÛíœwÃv€¼fxþêïQßÉœ©¹µMÃóÆ ¬Ãí¦A¯Ÿ–3ÔˆQ•rø|¿ß|w÷“tíÞo4IÂä’Ô²„JJjãw?ö±ˆˆxÏŸýY¶ÄLb=w¢¶½Î9¶dgg'666¤9Ú3<öUÆd¬ÙújGku•:ê˜ûÛ¯8ñŽ?ù“ˆ8­Xc.ÔµN2§l\}‹÷ªó·öËí+ÃɧÕ)<::Š_|1åkuÏñ~u¬êUç\]Ö6Ûn½Õr¾_ËKVû"ú‡ ªëº>oxo²Ãý4<÷=O;½ïùu÷^çÌü=pýÁüAj1´“TFÑ…À cò+³MZP+¶` ”h£MUR°©uŠ=Ó¾´´”IXÌœŠ‘,WMfR½AhŸÞ‹ èõû§'lîííeÂn­’ã;žÉ‘UuÃ6ɪ ‹Áž4›Íy’qÀŽUf؆/ÊQY;›`Äà;UYó´]ÈÛ#QÒ©‡Àïƒ>×®]Ké –N%’ÊTV 3H÷¬65,¸w‰k×®Å;ÞñŽLÜ$ýÙÞÞÎäh¶DUÌM­ˆjŒ'›?22—.]Êä5N®5XaèkøSŒ ®îšZK Ölívô»ò£Z#Μ"% %;ú>pï{X?ºðšÐlžVʘŸŸÏ(Ͱždȱ«óT;E“T>Q‰… )"2P[ÈÌk•T*Y__O Y•Ó`ΈØUpZ“°kôI„GÂ!†>"N^õŽæ±H’÷¨2/‘¬ÕÕÕ”³x¶B#"vß÷¾øŸ‹‹ñþo|#–ÿîïâïq(–Ö;ÏÎÎæ‰¤4ýXtìµH€¤û~¿Ÿsg}}=m+‰ŸuV%‡æHµOÎ'…#ýý™Í¼ɬ|â‰XyþùøÑãÇ«>šö½–§e'°È"‘7oÞL¿ùj,ÌsR:2sèâÅ‹YÅ)"2rÄÖªÌeìD<ÙŒ5ù»Pm§¤usÜœ¾ï¾ûb{{;:Nʌ̓‹/æº6Ææ¾È~©IÔìoÍõ²?™s˜}öÓ}»ÝnFŒHÔŒeÍm²çÉÑGGGç °wéõÌ3Ïœkæï… ÛúFÌL s3T cl“ÇLnmmÅüü|ʪ¶\è“îø†TidmZBÅ6c7à‚å®Éb´ää/ eÄ™>1âÔ@ÎÎÎæéz »÷ˆ8‹HgÖ çøøô¤=¡k?8ª^™ÔÁýI’°ãœÊŽrª$, ·—œr†ª­l6›¹¡å¦Wå>*Šsò‹ýýýØÚÚÊ|† |Ì%Ö8[ŸáПž|Èáá`™G5\>==ÿú_ÿëøë¿þëxúé§ãàà Úíö@«·¿¿Ÿï˜öz½|s¡VÒpMLLÄÆÆFÊ¿äÛ·o”3Ô×ú€¶y›SÚêÿ5ç€ÓhîßÙÙÙ|zzznòIÚ$Væ„5èDœ‚ìååådÝ0ÇÍf3~øá{ª€T™Iu’•WÔïôÎ$ æ×<ÞÿoÄgžz*¾÷ñçwô%ºJVžAj¡““§#Õ¤ûÉÉÓÓŠÙ 6v8ZÅ®‡tÉÔ#NÏ ðLë²×ë¥c«ìäÓŸýlü‚`áU›€!g§Í£*©d«Í kêÒ¥KiÛÙ Î8»wxxv²3Ûq–¤Ÿúý~:¼Ýn7"Î ÌÏÏçáiänuM¨úCzséÒ¥”ò‘HÕ±«k´æ}Õü¯*]4÷ìEì¡3¬óšh»¶¶–e[•1m6OåE*ƒi·µÊîJ–×Ïç×Ýyƒù{àõ÷ÚÚÚ@æ;€¥ò†ßÙÔ„DË‹åR²kdd$ëÛPëÑÑ€C\£.\Ȳ‚@gÕVÖ“õfffJSFD²¡Bÿµ,Vw}}} R‹Ã\0wõò9%å$V–óŽñÓb³¨‰²uãfœgff¢×ë¥QîõzÙ¾ r0gLåÖÖVLNNÆüü|j¶94Uï­¯½³2ƒ€ÇÈÈHt:*6áíííìcàL›†CÕˆ3]ÿÄÄD²ŠÞëðð0þôOÿ4VWW£×ëE§ÓÉM“Ó@Ûl6h©ì077—L®~ÂêbSkt‹T™ÃØÏ~¿ŸÀH¾páB¼úê«ìlÄ`•#g¿ßK—.EÄY]{óvX‚B[Ìùëõzé”UàI[OòãÙî999™úꈈv»Iƒ¢4Á¢AóóóéðÔò{úŠ3è=#"OcÅFÖ¨†DðZ)¨Ù<Õ»‹Ê4X^^N;²½½%7/^¼˜Ì#IDeåÍ3Žá¥K—r 1ÿÞs|üô°;QŽš7â>æßµk×¢ÙlÆOúÓt‚ÑÛ·oÇ•+WÒÁ µ]©TNàÌÌL<õ™ÏD¯×‹Ç¾û݈ˆxæ7~c w£ÚÑ%@mkk+¢Ûíf¡6‚md¬¿œ‡€œHÈûY#”´óœ©ùùùqgffò4×/ÿê¯F«ÕŠÙ_°üìŠ$O5ݵ¯FØ`ÛàÒ^PsÜ»×ëe’ùÆÆF:wžåÝ`û$~š÷N§“ß‘‡qñâÅXYYÐÂ+ÀY•ùàÔ‘ÉY°®ä™p@Ü[ÔÚc­c¹)úI$-"Š Ä8˜æµócD½ûý~žÑï÷ 9œ_wçuæï«†y‘ªÝ¶AÐpb‰Ÿº¹‘Zõ>ØN ÍFQ6êm4177—`а‘û®MËWK>bg€ï àk$@ø”ñÄ ¸‡* ÀrD$Ûäÿ6? £ä38s2È8Gúц ¤ywïê>îupp}ˆ©²ùaÛ%g05)ËÆTYËÂ%çM‰ˆ÷ñ¾6{€MÛª&Võãh Ì›&üÜsÏ%ëË 9)úGû…“ûýþs‡“ˆªÉ8¬XlàŠÔJd…THÿl5c,ëÐ/Ú_åXæ!ÖYßÖò£3zãáùq&åâ4s·ÊØZÛ5ÊŒ*ÈS&ÐgTLò CTïæÍ›Ñl6³6º¹Æ)išžžŽõõõ$êá,s\ä?€SµK^»Žvql+“_ËxNLLÄ•+W2šaÞ“žÇÚnÞ GÈ,"ÎtÏúèûŸøD4›Íøà×¾O}æ3ikT§&3×û±SæŽq%uª6G_¥$µæ=§Î\«uÝÛív¬¬¬dÿ|æ©§""âÉÇ;uÊí£é4õw-wi,8l¸nnnfE¤œ¿œÍš¯ã¾¢lž/¹Ú=ÙNŸ„|QÆš“aÝœ!E€ss¢êÝÙs¢öa-÷¨º˜¾a;%6³ÉÆØI²Þ‹CZs)j’àÙSið œK$‘ï‹:>ç×Ýwƒù{àb¸#"å @5Í$ð]£°¼ß3ÀO•@•õ·‘“ž,4›Íx衇â}ï{_,..ÆSO=ó73ÀXÔ“&H‡Í)¢XòÊ’2xBœUìܞM€“ÌFNëSº3¦ý lÄYýgD䦋m­N G¯ ôcãvww3Ò¡]dôù4—ª×Øä#µ®±>K ìVg©:9˜Fm®¤W·Û‰‰‰,χ¹0vF#+çýþi’âææf2ï[[[qùòåÔùªæáþÊ r,fggÄÖ²{@ßòòrDD–~sè’’oºˆˆ‡z(–——ãᇎÿøÇ91Ð### FÌsaoýHÇŒ½¥õÕ¿Âò3Œ6™ >=»>¬õÊÉÆ‘ÊNGœJ8›€P¾µµSSS±·wzèÎììl–\¬õî N×þþ~ÌÏÏç 4ã=ôP¾§¨°´°°0 ›«ŽS0XTó\2uY;‡‡‡1??Ÿ•rVWWóÐ, 4ÇøªvcqÊþ>÷Üs9¨gžÆÍ›7c~~>çLj,ÂØ²"~þýO|"îܹÿùŸ§M~ú³ŸM‡Æx{.{TÔ­ÛÝÝv»vštQßÕµŽü )÷Rã:11ïý…ÓYKÿ¨ÓÉ(€HãÒÒR&ÉrÌDÌyÏuÒo}æÚÚZΫtà°ÚìÏøøx\¹r%ö÷÷³"RM65ÏœM$ZQ#¥œû}¾ˆÔÌÌL2ìU6‰,â„Ë-:88ˆÅÅÅÈÿâÀ³N'SDz366Ù/4ûu,kô¯F&7È9(5ÚÉ!ª…%8°ç×Ýyƒù{àZ[[Ëjµ¬™²2 @Tää, %ã Ø<×ÖÖ’ESªMè÷ÁŒ«W¯ÆïýÞïÅÊÊJŒŽŽÆË/¿‘ kq°âX aGe!kYÕ2âØ¼ÊNcw«#akª¡¦yçè`»€áb ›\„!¶ùÚ¬9 ‘2 :\ŸßÚÚÊ X˺á éV6[Ò› )â,‰{d#àTØ”1‡‡‡Ñn·“]³›#´äËËËÙ‡ÞÐÓWGGGY®obb"Ö×׳=ÉÊFD&ÞÖ±³I›{6ËzR•ŒŒŒ¤TÁ<âÔÔòŽÊrðVVVâ=ïyO¼÷½ï¿ÿû¿Ïy <¯Ñh H^8I€{ÄÙ¡=Êü5›ÍX^^Î9qÊVWrªZûˆ³j5[[[yê0©T»ÝÎy¬Vý©}ÆŸshŒ9`ƃ$À;UIE-ãhÕ\ÀÔZ•¿Á¹TŒ™h¿+£ˆý®Q'‰¨ŒŒœž[ózÈ“ÆÇdzæyur®_¿žN²ü —÷?=?ajj*.]º”' ³l›sªÙC¥ÈÌÄÄDüø·~+uàZŠˆø‹|$!듊ñ6ל@úè;r4ôs•:ù›³oLGFFâ×ÿò/ó=þü×~-µöã¿°=´èœö¤Î3ÕÌ9Uœ¡ºŽ9ßæ—h©Mu^Í÷*9ㄎŸžóprr‹‹‹Ñjµ²œ#»ËqY[[Ë“[­å¥¥¥yo®ìïïG«ÕŠ™™™888HÛÊ9Äú³Yœ&@ÝZµõJ{’qæÉ%­!öBÿêÛñ­Ò;všmÒ§·nÝŠ££Ó2°—.]ÊÈw•¾ž_wßuæïkyy9YÕaö‰ÂjTf–&;‹Éž™™‰[·neø3"rÓ¨v¦ÖÎÆr®­­ÅÿñÇììlüøÇ?ŽõõõÜšˆ3 ßïŸ PV=º¶3œ üññqJ]}$¨u\¨àƒñÓ75ÚP“×8À40X2Çq® É177— ­÷ hÜ#NÁ9]?‘yùå—“YU3™ÆºVcÑß$ 6šº)b§H+´+"’]vh è~<òH\¸p!~ò“Ÿ Èh¿ZEegg'ÙsÏ£§­y;;;Å¢7773bÒh4âêÕ«)×j#"7gL¾÷ÆÆF|ÿûßgŸ}6Ù\š\Q,ï øˆZØh¯\¹­V+£’k9ÉjÀcèÌ…ÑÑÑd«¬Dh¾Ža•‰ˆ¢™OÚ»½½KKKÒ 5¨¿š0ŒéÃ.Ö6T§ªF¤†+š˜Ã¾’—±¾¾ÓÓÓqéÒ¥”ÚÄ4îõTZUNÌQN"‡‡n¼–-ä¼ÏÏÏÇ•+W¢ÙlÆK/½”–èò7b?–––rs"ÍøøxÚΙÄy6¡×ëeF­R´¿¿?ýçÿ1×ôc»ÝŽ~¿+++qtt½^/å#Z€™s"_‚- gßÚÚÊ5¬¼C¨ÈëØµˆH¹ÊÅ‹3"Æ1ºyófFó8dœh’0ò$€_R±ùªÜ¥9Å–øŽ9 ä‹åá{UZ:771P‰§ÖÖg[EÌD½¬ƒš¼~Ý×9˜¿Ç®Ê&FœÕÔ­l׿æfêM«þ®&ÆõûýÌØˆLzbhª[r)ÌÞÞ^\¿~=Ùá›7oæ3èI‡ŸY“w¼s5Î.'Ö«YX&W5î"õÞ~  ¯kkeØkµ¬’ûÑYJsr:jø“4Ðò³aÝlÝнÐ̪¶ëûá„ߪ«¯úïúûˆ³²—€d“Àx­{¯üž6ù\ ‘c l1ð©R’÷°Ù U{¤öz_}"bıªpƉP­I’_—œ7cqV|ss3ËhÏÓ7êSý䈔I.¯}¬=À,Jon“0ÕÃÌäªX³æ2i§®Ž5ö”œ‹3É®›Ó€ž¾ˆˆt±Øõæ‡]_Í5·¥:õÊNLL$##Ð_Æ_Έÿ³EÖ•¤xsðªkÃs܇“ì;5_æâÅ‹ Í|ˆÌ@6õä¥<\ IDATG?GGGyšðÇžxâuóåÉÇÐÆÏaûQÿ_ð0NüÂAª`o8*Š<áÔ {‡C‰°‰Tç²ÕjE«ÕŠÛ·o¿NeŒ}¿“Í)öNÈ–šà:œà)1›cS/ãdLª=ccH¯ÌuDµj>ÔÜû·¹ä{gÕX;sœŒéjÃë/ìéö=’?ãYŸÏ¯»÷:ó÷ÀU™lRì–˜A¾xñb† ‡ËØ‘¨T¶©Ê!h¾I]jr$CV+¯¼ð †«À¹ßïÇüü|IFKÅŠMPòÄ8 7jqV¹‡f®ÉV¤3ØŸQÇï…IÝ»&yEÄÀ‰ˆXe<}üpùËF£‘@¶ÖwP0ؘdìu·ÛÍ’Œ,ù.Ðð `øB{½^†rS’…Á­¹ ÂÚ€f-c‰ý¸«\ÃX{/l.öëìgØü™™™hµZñ¾÷½/Þö¶·ÅO~ò“xâ‰'r“Só»{›èêêj‚<}aÝDœE¢vwwÜ/,, T©u±•_5k_´,â4D bÆ+èìtþOöîýIÒôº ü©ª¬{UÖ%««¯ÓÖÌìÈ # ÂH6²d)$à°A² ?alä›0±ÛX²°,É„ÙõÈØ6ìD,ü»ìà5°ÁZ¾à‘0òiP÷¨{º§»nY÷®êÊÊÜÊŸ“'ScÀ&6Öê®7¢£oYo¾ïóœç<ßó=ßsžv2ýž  ‹½½½”b´Z­Ì4ÕîÞÃØFDÚŽÚ‡ZÍ`±+“Aa“2`ìQËʱ±±ØÜÜÌõJÎ àÒªP1ê¥K—bcc#Yó“““ØÙÙÉÀ“Ì‚Ý9évii)ÚíöðVø;66_úÒ—2‹Â7Èøéœ‘Ænj ¥˜v2 ®u%¨7G|pmM*3jüÄT ßþ:ÿ¿õr • ªÝnÇÃß͈é^ÃÇÆ2PÝn7³‘u.ú~v¢;L•üÔ‚ßFãì€&•‘%©E²Ö*!séÒ¥ Fùgµ+|üìììÀzZYYI¿qÖ!Š=XßËËË;6ã=ÍŸŸá—e°ÇÇÇSûïçØŸFêÒétò´tëÃÿMMM høçççsß­ì%ì¸ÝngV̱¿¿Ÿ¾ÙßßϬëž_ÞuæƒËÆ H‡ÊIb ¤ç¤‹ÙŒªˆñÙÊ J­s<˜ŒÏÿæoþ7¿ûóo~s²‡RÁñ’)úá–d###1==š$@.Gï°"Ï th&ˆˆMÔF%bÞj»9TSeE#"teæj`±¹¹kkk9ÎZ¸¹i€BS̹ ß!e,õÌ>Æ}aa!îÞ½ÉIÃÊä¶Z­h·Û @±e? Ò{M ¤1ñæqtô¬#Î7’Õò¯êÍ©ûíííÅêêj‚3R—V«•3mõ… ücÃ+‹‹ÍëvÏZÙ­­­e𱸸˜’Œf³™‰`[:Þ%!ð¼Ö™1ÀŒ’€ÑÂÂB´Z­÷!qQD¸¹¹™m5±‡µg<ßáï‚h [×'‡¿u»ÝÀ FkÍÇxlj‰³ÞàÝn7ûª×®P_üâ³7¯×‹ÍÍ͸víÚ@‡A'`¾¹¹­V+VVVâé§ŸŽ^¯[[[q÷îÝâÚ‰‰‰ôYÃò£ÚöOlŒ÷ööR~ÁW È«Nzll,®\¹’€uWÏoÝ~æ=ïÉ`–_ª,<É›,×Àù¿Ë@›¶eì<ÇÜÜ\êªu²æ·¶¶bjj*Ûžò™‚°Z£$w»ÝØÞÞÎ{*Xf+SûBD¤4¦Ü:ñÝ|“õX³´÷•(Ð’·2àÆ—="§""³ sssíAëÖÚ${ ÀÄ=ík|B "ú™>ï=99™í=7ÛAÚÔ¬w«ÕJÖž]òg {kŸú±±±”˜ž_æu棫:3ÇÒÙ*0Ç^Õöb€CÕyû,P Ø 3¾cd Ùl–ŠÙ†ÛŸEDüñ·¼% 莎Žâ?üÆoDDÄ7|ý×ǯþÚ¯¥ã$¸lÞÕùFô%5 êݼ¿gÄ®XžÙ=mtéTŒ¹´´”ÿV‹j+}~½ ¡Ê-ªTÀXõü ¶Ü[÷ÝT*°HjÑ´û™[ÚhÏŽy5~+++1;;›²Zàè~‡‡‡Ù©0¬éïá4qe”µN¬Ï&ƒ„åû¾ëëëÑn·€€ V±·q¬ýÊ±ŽÆªÊ&""YAgm™Çưb•±­sPëC0ôÖÉŠgFÐä½}¦nâÞ׺f‹tþÞØ® '"O2ÐY¥¾§Ú9¬(± Ç<Ÿn·›ä;SH8;;›A§ÓÉÖ”|€ Ô;8 j||<.]º×®]‹n·7nÜÈS4ªem9hªvˆö=æÖ8T)…âÞ*Cäö÷÷s³9öXíŽíc¥eö÷÷üŒ9óLÆB¤jÆ5(d°šð*/©Aƒu[ý™{ŸuìñÑѳNVZ¾šsó.c1ØZ¸m² „Ÿ¨qAµ#ßÉv0òÆK€JŠ&(­„ rÁž`^Ø/Ë?j`P3ŸHc‡½g_>~\¦Æ³œœœd±óÁÁAìîîÆÊÊJÚ£z‚ˆ+¶%ShlίG÷:óÁEÏ 4w»ÝLsŠ:•òýÅ/HÂP7]`ƒ#®a´*(¯mܤ¾=›Ÿ! ¨€S7¬ù~ËûcÑû]pãýþø[ÞŸûÿ!;¶+å»lœ¸¬¤IB0ag€Išß&p||œ,iDÖ:ãXY0€q ïØØXììì$€&lî~ ü¾±±‘ÌxÝë&h˜^ =y…¾ÈØ.’𥥥¸råJö Ç”Û`ÜË—/ÇÛßþöxë[ß333 ¨~û·;35ÆŠ[Q˜ñþÌ Û™žžNY±©a…½óÄÄDܾ};^{íµd-mìU£¿¿¿;;;qíڵ߽½½}µ±ÕÑe?¶¶¶2€ñ,l…|Š Z'þÏûÔC^‰¤f»‚ÈÃÃø~ýz÷ÅÞ2:õü€K•–]¹reÀ 8*ô¯^½:ðw@³ÙÌyô̤ îƒÕ&¯êõz9¯¯¼òJ¶‰U !x¿yófLMMeñ¿µ²²’þäøø8–——ãµ×^‹‰‰‰ØßßO†”¼‡ÜJËÑ'Ÿ|2ö÷÷ãðð0¾ô¥/å¡K2•‚µ*+‹ˆ”ÆLNžucj6›ñôÓOÇÞÞ^lmmå¸TIÀ\qµñ='ö˜íðQäGì¥hÖ/;8>>;üËiÚ5ë´´´”>¡Ý?99ÉCîø[L£ÑÈV¬:»ÈÖDDÚ?û`éªdˆˆ,ðÇÎÛœØÊß©‚™ê£622wïÞM‰”ç¨fRÃ~|)a È_Y=‡]x‡å™Ïʪ  ""ÖÖÖâÂ… Ñh4òp?÷•YÖ(""r½œƒùGû:óÁU #b€Ç8s~U»<œ>è3Ÿ“““R²Œ)^[Ur>X9_Ð.JWs~;;;±°°Eºg@>¢¯]z&&&âmo}k|þ×=ßµ2%Ré2 œñÄÄD¶l\GeïiÐmzegoóR×Xçzw:88ˆ'žx"ÓÒX+©èˆ~[Ä`¡n½WDP­óóó ||ï~÷»ãúõëñÏÿù?µµµÜ +|ôz½»´´”›¢î'Z’ÑdrâµÀ¸ö¶™)öóü:¶<ËËËÉ~i5HÓ_7pfg€| }ñ‹_Ìñ=>>Ž«W¯¦¶zz:®_¿îÏý¹@¡ÛíÆêêj¼éMoŠ[·n%Øi·Û¹ñé_Îë ;ð4:˜ÁÞGPUõ͵¤ùc‚ ‡.ÕžâÀW]W˜õ‡ÆO<1À jWuçtÕä-À©½ô…ˤcÈ|‘²ÐºÛÜNvä³ôÉUÏ­ðM³s¹ý»1º²]Ú²]kQ@*¸ÕK]ö¡fè*s©Ëù¯mHÝ×Z¢mfWGGG±ºº;;; ê{½^üÆoüF[‚%šfÚç*3ÄTٌچÓÓÓ8<<Œv»lh•"IÔ‹¨—ÐÊP!ײÙld­ªþ`> 4ÿÖi­W!sͧùö}€+ÛŒˆ´çš-˜U Žv¿ÖÂwÊÄÞ¿?NNN²V'¢ß©¬|5²ºÆÌ†¯–%ÜÝÝÍl’zò?ë\ ©”V‘ä:U6IzcaCÓÓÓyîƒbxËíÛ·“P ^}¼ ‡í¨a@ž`èeöÔÔº$š½ŒÏ’ «ðùõè]ççû>&WÕ7V@Ño»VSÊŠ„sb=kK®ãããö}.,NDäçë÷r~þ½2ŠNýyŒH½|¾¾ßðÏÖÏù¬?·º¬µ~»7 Ô±ªšQ–b_?SAœ@(¨Å[ÃïTßÃ|T–ÞœÔû¹ª>Ú=eQlè:îý¶mõ8{ïZÇmnn.®_¿«««qåÊ•xâ‰'âÙgŸ'Ÿ|r «bþ&''ãÙgŸ·¼å-ñÌ3ÏÄ3Ï<Ï>ûl<õÔSqñâÅüZ]…¯SSSY´j\ØÓðWûõµÀØRk7Šº13ÏTÛèEô5ÕõgØ PaüØ PèÞÿìŸýo™}©¶è™«Íš®2ˆú ÎOðoÇÇÇ)ݪ™ iΫ×±<†/-<½¿y©Ù'÷g‹ÞCG‘ œŸŽ¯·–ù% Ý{ÇדȘ烃ƒØÚÚJYŒ ¥õÓétX#%ªïªÏ»µµ7oÞŒ—_~9߯úCçßkM×÷b_æÉUýÿ[ç²ÚC#cU»ó¸ÛáìoìZ­V¾¿Ÿ3/Ífs@—ï^µ`˜ÿ4–ÞÓZªã\ß»fŒÜ“[ž«®k÷¯÷õîžÏ=üblÍc[þ½ÚhŽå½‡Û`ú®X³ÅºÆÝš;ßË?ñ‡õ~Ö¯¹cö÷ÞίGï:gæƒ {YéA"«ˆèw V$ƒ©'¦r À vS½ ƒ–zu…tõpLkýÎXaäèèh2ªž•Fxgg'[¨iíå¢[ÖIg¸X¬2ÞUÆ)ôÎúäÛ¨ÔTÇ-s ugD$[ŒQÁ,a±.t䨯ˆHÉÂ0 ô]ƳŠÔ=‚ÌË­ ´víø!Eo|¥±Ù‡4>ÝyÝtb!‘ Æ2a;N¬¯¯ÇÆÆF¬­­e&¦ÊTØÄÈÈH´Ûíˆèúb|i»I½0qÆrss3FGÏ:Ý¿?e,”u:d}ÇÇÇcee%AIm3Hæ Å£yÅú‘ °ÍÚYÄç±û˜KLçw~ç_Ÿþéÿ5~àþv&Kg½'»% ¿¨í÷ÈCØiƒâìz:-y”iØp[Y|cjÍT{fä8Ö—q„ù?Y¾Aæ3^©ï4ßäm£££±ººš ÏA¤,d###±ººšÏLææÞü±ŸœœŒ»wïF§sÖ1¤8nmm%ã=99¯¼òJ¼úê«YëB’Ñ/Ø››K¶˜&Ó«`Ò=}–8ª®·‘‘‘ÔÙ'÷â°â5“×ëõb{{;c-Ä´/èçï„f \S÷s²¶¶–þbbb"–——ãää$S"éÙøq—CÖ¼‡lMS­&±álX6Ϻ¾páBt:”m...&Э6K×Î7Ö öüÚµk122’5ü/ ß½¼¼œçRdm‚¬º*õ2öNÙíÑÑÑ<ýw~~>3=¤7Öù”‘%2¤lŠËÇÇÇãÞ½{{Çùõh^ç³û\§­(Îf]“ˆˆV«•ÌHu&,éEÒŽzr=Í#ú,Kí!nãÄèÐgJ+s–À ©Mø‹/¿o|æ™Ôÿ*Ì}ðàA¼ôÙÏt³Ñ„ÔÄwWfÎF²´´”)Nš`éÒªé–^'3Ž´e´™W© FÒF[e3NýSØUû‹K«ræUd£èccc±ºº»»»ÙÒÒænƒ±™aªÝçôô4ßUtlOBûûûYº¼¼÷ïß7nÄSO=O?ýt‚€ðÞ½{ñÙÏ~6nݺ¯¾újDôw²“"Ô}Fc ]‹ +¸«Úa,˜¢ºšaÒÁgsss ¨UzÝ3 Œƒ WÐë~ZÓa I¾€R¶¦˜¨™¿þ׿+~ò'ÿ—ø®ïúîÔºê¼ÌæÈ?ê™@;ÉŒƒº0¦•fƒµ6€l)¢ðØØX\¾|9ŽŽŽ2ˆ–Й#Zé©©©ØÞÞNªÑÜ#þ>==Ag§ÓI‚¡a*È×¾’þØÕ³:¾NMÒ²½½ã~||œó¥¨È<==Íõà·^¯7Ð5‰ü¬Óé$¸===ÅÅÅ|&EŠŠ*Íû%ãÞ­±*Iœ™™Éy÷îÞmgg'ußž—¤DP¸µµ•AÐññYo6Å_NNžõŸ'Íš™™‰f³™²ÄÆþþ~ÊwwwóÞ»»»qåʕ̑©R¾6 :vï$+°½½€ è¨ €ÅDú ØVðѦ $ŒI…6ñ ®j‡“F£ Ú°x‘ÌæC§)V\HØ4€y…á–¢‚¹ÚUÅ3]µuÚèèhܺu+>ó™ÏÄ7}Ó7%xX___ù•_‰½½½TÁZc51ËÀ´Äßgff°Gœ£v»‡úDôÛ~Ò{cû,Š—ÉY ï e Ù&ܺ¹wï^ög(õ´¬©………ØØØÈuõ?ð·ã'òÇ÷}ßßXêÊŒìUöæþ²*(²#»»··7pîƒ5ÇŠÊRXÇ~ž&ßX¹°›ôËÀ'ðÒÒRìîîæ³((ì­¬¬¤ÿ±¦uˆá“dbèïÝW'µÕ_‘zÕ5@c¸Õ*zýâÎÝÝÝÌ,ùwck½U͹ukíÔZʰûnã+³.d?éûbyy9ߥv¦1Ï<ˆf³™ív;Å—ÎY½R•bÈUòsÑ?`¯1ÎæO¿z÷T”j=«»1ÞW\×3¢ƒorºrÍŒ±YXD‘wn| جsþã­[ÖÔÔTÖ öÌ+0oï°î]½^/ v½óÞÞ^\»v-×±Œ÷¨šúF£‘{‘ X£Ñˆ7¼á ±±±‹‹‹i;cccyŽ ²AÈg½ž¼öüz´®sÍücpUé Pƒ™«iu Qá6±2ÛÚý)ª©éÕªg´áùœMm¥ˆa© ¦ƒ¯§aº""Þþ'ÿdü±çŸÏÿæoÆ¿ÿõ_Ï~îsñKŸùL¼í­oÿáé§s´ÔC{€›«_Š„tÛ1°é¸fffr·iÑ‚ ©5 ÁFŒ´Eg-®lš` `¬ i||< ÇòëŠ" ³( “ýˆˆüwóÓhô‹&ÍÓþÏÿ9nܸ»»»ÑëõâË_þrܸq#666ô,..ÆÒÒRÚÔîînJœ¼¶kaa!‹Ójzzkk+ßwnn.³1 )­A;cÛÕÖ""†™Í{LLL$x"!QÁp»?¦Úf‹U×ÞU±¸ìU§Ó‰¿ñ7>?ó3ÿp vÃmŒ§§§“%.Æر­ -¶¨¤9ߨØÈŒ’{³/ãR[×Ê@ ‚ªÍÕ,{ì[c@ôp=66‡‡‡™‘p_¶ Ä)RïvÏ:ÍÍÍ ôö.öT‰ÂpOÙ!RAœ€Aðä"Îä{ÆT̤JÖÆááa‚,bõ½Ã—¬‡,!0lþÙY0là_ëAn|ÒÜÜ\feübósss9FÆKéFÕ¬+øæ»dú¦§§“ ô²1§wb;¾·ú5>lqq1¿×ûš·ˆHb¡úîˆÈÏʲzn{bŠŸ®kΞÈç)à••¨A0ÂÄ3û{ÎoÕ"^ ^†DÇû(ØUx>??Ÿr¹š˜œœÌñµÔ ¹óëѽÎCµÇàºwï^:-ì)@§{ FCk.¹¦|9$]ü»Kú¨À¾UÝ7pxtt”ÌЃ}²ÈFGG£ÕjeZ?"â—åW^÷]ÿýﶤtU VYo›¯ ~uu5bD_tÝn7á®òÊÿµsC•z>|sssù>¯ý €Êæ+H°ñ·Ûíl1@T†¿×ëÅÂÂB,--ÅÆÆFJqȘ€%°`ÚëaXGéÜZÌæ½¿@“““ñ ¿ð ñõ_ÿõqzz/½ôRüÎïüNŽk=±0"œžžµÝk6›yÄ9Ö¼Êm'}ÏÙv:X]]­ìˆù¬]‡\;;;9‡6|…gX<¬{D0ÐÃ-———c~~>&&&âk¿ökãÎ;122÷îÝË®&<ˆïú®ïŽO~òÇ÷ÿßJÛ5Ö4°@º`Mf«ÑhÄÂÂBÖI`±­?z\¶Ú@Å»m‘@¤Ó:¿Tp© {ªAXD?û³··—ÁÆÊÊJŒÈŽŒÕââbJ¸ª´Äów*ŸM’JDD%ÁPíùoÍÕuê½dÖßȧù7ö( <ùõ3ûûû¸‘Œ°ýýýÔ{ó ìγ®¯¯çwY7äB€ÞØØXf>ªt(øðaê§?Ó£onnÆÆÆF®'~Ö8ÊÇãããØÛÛ‹ÅÅÅOÖ{vv6ûšONN¦¯TÕ,N? [ŸÛÛÛ±¼¼œs-¨yc¤8¾ÝngC×#$Áøøxv%«ó¦ó‘@¡2õ|ˆ÷­­­Ì\»v- 1û¦}tggg€_ VAœƒ‚_æWo·Û;wîÄöövn†¯¾új¶Þ$ñ`#µ*4]¨L¯ÍPpytt”-’ l ÐXk0‚¤7þ4jIùðáÃlO'õM¾4>>ž-^­2Es@­wU¯¢m\³ÙŒf³™k‚-|øÃߟþôÏŇ?ü=yoöõ®Ò-@Âð6ò*»9==­­­=1‚ä#žìauu59 ðàÁƒ<´«ÕjågõÈØ}·?½«‚Q¥N)UÆWe3UZ!;â[­VŒŽŽ¦LO&PQhmSjNªvyff&[þÑCÅôü»»»xðìôàà ßA¡'}=¹ EVf\½—‚mR¦‰‰‰”l'ãë 7ÁÖýû÷Ó^çææâk¾ækâk¿ökãÖ­[qãÆ˜Í1À «Õ‘!öwŠýýr±§7óIÆW6A©•îÉÉI¶,6ÿˆ ¶ACeŒ·ÛíXYY‰K—.Åúúzê÷ýᦠö)û»ž+a®øÌñññÔ®Ë)PxÍ IDATtðëØvs!hÄž×úWKóOBTÏ¿¨­£Eíl#{¥.ÀÙ%ìÃÚ›œœÌû...ÆÍ›7ÓÇËâίGë:ŸÝÇàâ4#ªGUW© ƒEÂäDôÎÀºåW•-ЉV ¥ÏÔÏù·Ú®psßʤÖû ¿ßðç€ ›_Í*t:ã¾ýªãV¯ê¬ë8UVÿõZÖ–Š. $)€g¨ßUÛü ÿŸw~Ö:tÔ2 µKö½JJjkJŒo ®zè‰À¬JŽŽŽbss3;×q‚ ˆ~1`µEØÿ3Ïèw›ãð{«1çµ¥_7Á‚¿{iwïm^ü ÉODd{Kïa|Ý»Óéd7Fã¬ß´9â¬ká{¿÷ûâçþçÒ¾dHâü¹¾‡ŒËÖÖÖÀÔõUÿÏ­ LµÃšqè’ÿ37 ~½Ûðú1O­Vk`<Èd´ò”ªEªÆÒ3ø3[,ÕϹ̓÷÷»µá;üûÖÖÖ€OtVC-ü®ïãç'êz¬ùZ`ïªóéÏÕoÕµXyc^mQ&æŸÍDD¼ùÍoŽ'Ÿ|2–——³Kаo«í }o}¿Z[Ä—Tÿl}TŸâkvÓ˜ONž*gœfgg³˜•í ’½¯ñô¾H£º'Õye‹¤‰Ã&sc °áºžØd½¯ùpÿºÖç­v9ì7tbž‘-XÇužýbcõ}¬¹ú>|lý<;¿Ýkì{¿÷{?vëÖ­øâOüÿý,ç×ÿG× /¼éõZɯèKš–¤…¬ C—‘*»Q È J1*¼©šÛˆÈ4>-`-zRáOƃ…Ôz«Ê jêÜÏTç];S`ΰãF#5”>+- üaî"úºE‡-Eô Šk–Æ[Óü4¡õhƒ1Ë26¦ª9–IPägŒiK¯×‹ƒƒƒ<ÈÆ:55•¬VíLQ%T'''±´´”¬¶÷wè†ÃZ '–‹†)ó.ÞWf¥²œu®ªÞ]q¤qÛÞÞŽ£££xÃÞl4^›Hš_ÇÎëºá ¥×ëeîpö¨ÝnÔDœ7-¨ÀxNOOçÁCƤ,"2HÀ$[‹îïø…øéŸþt¼ímÿgÚ¹,&°±ÖHyÈ@j½D·ÛÍÓ•}ž<¤Î³lE-B¶dhFGGãÒ¥KÉpZï‚<ß[ÿÉÉIlooçg¾³JžªÚÿ†´ÁØeÌùÌÌLÊYjËMc!óÂð[‚@¶Áfèßwvvr ™áZõ ¤)ºŒr(Ö===Íl±ÞÚÚJ ©ÌÕþþ~ʧdÚjÌèèh¬­­ÅåË—ãâÅ‹qéÒ¥¸{÷n|ùË_N L*ç™ÉÝd5Õ@y n·›Ÿ}ðàA9½^/ÖÖÖÒ>ªtð¿páBž@Ìwð2¥uÞ«„ͼ¤$Q¦§v“iàÓùrÝ}X‹Ðk]„ñ÷]ÞÁº$w©õ$lEÍ™V”|›:,÷ÁÈ{wÙDû«àATÄY€æ4óñññøÀ>ðÂç×î륗^:óÃõâ‹/榩sN“ sœZM5K+Ò<øœ¨M¿‚6)cÒŠˆþa)œzek·éÏ©©©xúé§ãMozSž ¬rúµÓ&Í “ÿ>|˜ò}æmÒ—4üœ4Ù…Mºj9+klCÙÔ8y¬´Ô®çŽ8 ¤VÕ¹¹¹ØÛÛûŠn+ŠE±VŠ÷tHˆˆØÞÞNƆ¾ØóWö\-‚þó€©: —ó$@  üøøxàd7###©gFGZÞ‘yBêÆ$1nÞµë¤!NöóÀ>æÙßI¤†¿^¯—ZÖá"ÏZàVÁ*Ðc€W?oÜz‘Ï­“PDä&ýu_÷Ä‹/þl¼ã¿cMrd3¯íˆÈï&•xøða²s šµƒdçØqkß:êÿùùùh6›’L÷µµÇÿúÞ â|_e±IÁŒ/9FfZÙ¶Ûí”r¬˜F£‘€ ðn&ó§Ž@$/ª5î`võl «â]ïmýÙ:"«Q”ŠI¯ÄF£ÑÈ1á{­ºu’»‡Æç?ÿùX__»wïÔAYä€|­sssYèê»ùËJ`ðƒØaF»ÝN‰ŸËÎka=%ÑÜÝÝÍz6066–66===`ߊÊí1d7N'‹ùùû‰€ÏÒ~Ï“hÉ677sìj‡7’2AB†å˼@ŸTmqq1Ïác#"í›?6wµˆŸ/á#¾ÚïI##Î26õ¯þÕßv8¿¾:®s0ÿ˜\/¼ðBnHF#‹ü0È-Ÿ¢¹Êda)œUí„ÀÑTpZe++++ùóZ°ÕB¥ˆ¾–ß½‹oø†oˆoÿöoÃÃÃxùå—Rç6}ïUY|ƒ>òW¯^Í ­Ûíæó¿u£¨,Ž¢R?k³ÀLG ™v–T ´‘Õ6€@-l’r¬ÝߨÔî6-à^Ÿw©d»HT۪邩n½&°¢Em4©›ÅŽÖa°V(­æB ¡K Ö¿v~B€c pbøÜÚ¹ ~½ÀJÐn·ãêÕ«ùoêÌyfXáFã¬'¾àCö¡“V–Ñ)¥ºäGU<5uv°—Ö‚ú÷½ï3ñÉO~"Þóžÿ;Z6. aÖme‡Zå;€Js S›–-bcþ ^»v-¦¦¦âÞ½{±¾¾ž~HD¤ê̽¬W]&6Ï“““…{ûûû™åÜÍ?°W3$N'ýŽ –5ÇèóÍ“FÇ'“úlÔgP¤vív;[h †òE`’Ð I€/`•mŒˆÌÖXíXÂçY5cÊ/; jddd@Æ$ó:\í½Ùµã’‘”õ1ÖžÑÚh6›™«~I±¼¼œX­+¾ý½®/>«ö‚G0ðcóóóy6ÃèèhÂÖšzr­ùª{™9___Ϭ©¢út>?öe`©àÚCÝîÙ™'y ”›öFd”` ˜hOMMÅ?øÁÿR8¿¾Z¯—^zé\3ÿ8\œ ‡wzzKKKéÈë!2Uî(@¦¤ÛífjßæS ÷öör㺥$0NÉæMTøG# DÝ»w/¾ð…/$ ÀØÕÎýÂwb=w»ÝNc-2„°­Í¯2n _Äp¬$KUŠ222’›¿÷4Ö¾˜Æ–Ú$ëænƒ¨­ `E¯‰íî}&À–=™œœ`#ú]H0_Æ\SeŠm=¿ï*€,h@µíc+¾ÃXÙ˜>ŽO}ê'âïÿýŸHfÓܤ4Æœæ_¶£‚P²„ˆÈn7Š6+›ÈV€¶áྲæŸ,Fû<ÁžyÀjv³\%u VðgÍ`_ýŒ )áÿø4¨Ê׉²JXÝùùùm³ñÃ$›£¥¥¥”‹ÿïß1ö1 {ò tÙccgç$qsssÁøëk^Ù>{Àðֶò¯ä(•í烀IÏ\ÙñjÓ‚%?Sk3ø+ÏQÇÞ[[u V)L•Ÿ-//H߬ºg¸[“e”U"k,WÙŒg¯ArmOj¯`³ü¤ŸåÏ¡à‚ÿ•±ª„‰Àߺ5Gl×¼òÕOÕ̪,‰um?«õAˆ‰ÓÓ³6«7;¿Í뜙 ®ŸýÙŸM†9"’Ŧi;k`D?•ÊQÚX°€‚€Œ£ˆÓO«\ƒW™9ºæÉÉÉØÞÞŽ^¯{{{O°GëëëqëÖ­¸yóflllä;جÁADÿÌ—Ž"@9@2 úmȵ@®~Θz^ÁMÕìúþaà©b-Œè³…ô™6éhŸu`ÔîînÊCFGG3h6›¹)ÈØð±Gæñ>6\ÝVdô®­é©ý33;;;ɤ[Åfd*À¬Ï¸DôÛåÕcØÙ¨ï­µ dæÛ˜GóEÏ\ÓÖ²Q6|@pÎŒ·n>50*PUÈ&c177Ýn77e Œ-ȼï}Ÿ‰O}ê“ñÎwþbÊ<'ÀIÒ"0 "jÿj|§ÓIæRŠßIÍ![¨@Ç÷ñ-µ¸f¬“ÙÙٔꙗ^¯[[[` 6j­Àøøxìîî¦,°¬Y§ª±ˆduù9c+€Íu«'[Ä [@PÅ7V‚ÈÆŒû§ ³}š|sîdOc-(ö Þ¥Ûífç1ÁŸ]I@[ÆŒŒäxONNf¦T¦ƒ<†| HGØ'Ö`Öx±5ëÏZQà[I‘ˆÈnɪ›‘%±ÎKU¦é¾2_|„XFF[×…ïŒè×CÉn˜7sÉ¿óþm!%øVï"{===Ù*ÿ.ká”Z1Ä ùY=u¹ÖT²¦>ŸuÂ76øKé/ýQÄùõ‡ù:—Ù<&×?úGÿ(,'nóÃoŠ¿l„UËZe œ Û=ªD§²YUjbóFÈY8!EŸØFGGckk+œç›››Ë穌M¨Þëk#áè€K›³{`|Œ¡ÿ}¿û#ÚE v~À+ö<—{Õv›Æ‡ €IÛX±r¼Zã`3Kp]7Íʬ›F£/^ÌÂ\ó ¬`_eVèÿ»ÝnÚÐ||œàÃV‹ï<[µ+,*ÉFD Ø€Ÿ­,šÍÎ HI؈f€©r Å| #ú'ÿ üª¶|{{;7aÁŠ5¤%¢çc²D@0;h4ñ®wý›øñÿx¼÷½ÿ.ŸÝaŸuʵÁ*»\³#‹‹‹ðŒa@„ŒI•àx'¢ °R#"[þÑ “ÿÔâÔÛ·ogg>a~~>m‚VÙ‹8Œ›››d ¢¬ €XP†q¥ï®L. +HEÃxV Úz·Î}/&½jÂ5¨4cfŽV53©¨W`©,v¿f®:Nµæß[\\ÌqZGGGSÞÑl6css35™Ñîîn-#*óO&W3p•²·Ô Ðک칬q­ù0÷üËññqö°'Ëó]‚Ð*AÔr”¼¯f{€cÁbÍ*’ÑUyŸ‚}º|{€±DY•y÷ì²#ljwww r­= ü÷÷÷s_`Û¡9ôòÇßömßö@ç×öëÌ?&׋/¾˜ìImëU7Q›e•YÌÌÌäÆýz560ZbN ¨’.ŽˆtöuÓ«àÛWÓ°U2 P Ûì}!€Ñs;ÆšÃ<*Û_7#c-áðØ*©…Š6\ÏçÄSà[• ³)Ûü±ö‚©ˆþV¨à¤ê'çææ2H¨LhÄÙæ\7kßM²#óaŽm‚O£ÑˆÍÍÍœ_Ïk|Éq0a°±áÒÕë¸"hëõzyð`®|¯±‹ˆüÜèèh\¹r%ÆÇÇãæÍ› ¸´7´É»Geí#ÎúMssssÙ1¨¶:|ø]÷›XXXÈg’ª5õõõ àFGGS3ÿÚk¯ °ÞÕv"úçB(œ~ûÛÿUüØý½x×»þut›{ÕR³Ýn¬Sã:55•‡séæ4,g*­/¯ª” Èá#Ø€ìi€µ)(¶æ|À¸²²’é@ÄÆÈ¡¬“ZL޵¶ö1’Ï{'­+Ù²`E°U¥3U.Tq=Vð ;V¿«CÁ@ ÚùH@[ïp0„­VâééiúvÄ,’ùÇâÖ“DÍ'¿à½ø›v»„DõeÎrà˰óÎhðovŇh° Ž‡ŒŽ$HÖ±î5€zcÁ??\>°í÷ÕÕÕÖÕ7Ù[Hï|ßøøx¾ ,íuUšè9tP¢Ý—éŠèuÓÆ[lŒ/°ZÇÈ26öhí™OYZÊ&çÝlÍë\3ÿ˜\ID¿3DÄ`vŸÃˆÙ„m˜~ ÿ\ý?LÇ:,ÛÑÿ Ö Ëèçõ|ÿ½¾Ïç‡ûÓüûÝg±ÍÃïK6á9j?ñˆ~KÎÚ]¥ŽÐX笠ªŽE3µ‡ûééi’ús}çÚ_Þ&íÿÜ£ö\¯ÿggggãâÅ‹ñÔSO ÖÖKoï4Ü3ߟàÊ0Õñ¯ãûzã=¬'9©ŸÌÕÞÚ‚™*Ûð3-EôR¨ëçjÏï:ÏæÎ3Õçª=䈳'WZS˜RŸe.ïå{³ƒ 4¶õ3@”ñÿøÇ<>ö±Í1Jª´ÅØÕùpÕ9®÷7®²Õwvvò#vbíÔÀÑÚg;î199™=Ùë{–špýÓ­3ã^ei>ûz¶5lý“2kqiµ{óa777s\Ø»ð³Æƒlì«MVÛðýÆ©Õjå=< ¿SçÝ/;ªó5<^ì¨Ê^‡m[0á¹¼›ÏV»aÓSSS<œ_æuÎÌ?×OüÄOd8Œ0ÝlD¤©Hú[ ,m0v—cáµ”’Äú×ô¾Ž˜«Ú^ Q{ŒŠÎ ² àˆ~±#VLŠã!å\Ooõܘ_Zò±±±leG“IÚfi€1€5|ùòåd“¿)Q©]@0וe5þŽNÇJaü°’ÓÓÓ©«ÇÖõz½xç;ßßùߙ϶³³“ Tí)í(tL“q©úq6¿J`¦¦¦â‰'žÈÂMLöèèY§œÌ˜?L¶ÃV¹ =3–®v¢¨…ËdK²(Ø(’,l¢±òîŠ@𪗒©©-áȲHÏ0–Xdl)nëʘbÙ0ø˜mßS»ÝØØ‰¿ø#~ðÿN¼ï}¿”r%€Á÷[ËÃul+©ÞÊÊJ2Àlœ½5›Íd=§¦¦Z=š™jDäzÅâc¢+JÂáß}'€Dò¢S€Xktø¶"k§5"[Ë—/G»ÝNý±9”íÒ –­¬ôÕ²•2[æž¿ét:±´´Ï?ÿ|\¹r%Ôñ䱸Hbà«„L¶èo|c\¾|9"";‘e˜µ5[ä~²ü0F¿fëj±k &<·Ÿ1—²-j"ÔHYo6?^Oxv¾‡Ÿå»Œíÿj–ȼñk2|ŒÚk\}C=غ௖——3ÃRëÀìö!à¹62°°,ò¢š]¨™ºZØ,Ø´ø%ËXǺõ°[ ÿ… boo/ßéCúÐ;p8¿¾j®s™Ícrý“òOâøø8Ó­õäɪTÌTå5m/Å 4H?Vg.P$9Zx›T~-Œè3Ëããã¹¹*zª®µ°KaÙÇýÃk0/ºnDôÛÃѨº§4¤`£j%±/Íf3‰t>Ð~rr’žµjÊ···t¦4—‚úîçýüÙÙÙØßßÏw±ñÓÁºLÏ………xöÙgãÉ'ŸŒ_ûµ_‹{÷îÅöövø‘îÐgV@R7zò‰ùùù¸~ýz\¹r%Þö¶·¥d€ HW6 èš(€ˆ Ù{{{ ”È/€À³‰­«ò ˆý*¶[^^Î@UÊS[znkû.Xj=»4_N'õçj¶··\û^ö r/ÏîÙ’¿ŽŽÆÞÞ^¼ó¿ŸøÄÇ×}Ýÿž:yºÝtz6ýåkËÔ™™™X\\L0§máêêê@ æzii)Ççøø8³ä-ìFà:<<< fNNN¢ÕjåÜòïÕNj?ÿÊdËŒŒÄÎÎNLOOÇ¥K—ò1Ú˜Z¬¬[OD?s#€¬z§Ó‰gžy&–––ââÅ‹±»»›kÔZÀ ÓöóUaE¯‚2{“û«a›5“iî¾ýÛ¿ý¿ί¯Òë\fó˜\@gM÷Ùx±'€^ae¿€ñª%õy)Ft˜Aì9sàC [C-ÀõÝU'­cÐãtb±aÚ°aXj‡[S½´ÆØ[›s•~(´£Ÿj]X@ž#ä"b ðYÏX Ëj§6½2Ï–íèè(nݺŸýìgãöíÛ±¶¶–݀تÉõä.5Èòï²×®]`­1-Ðlêõ±[E`ݨɘ™™‰•••délšÒó~ ÀÑÚbbbb ƒ¹2FÕÆ¯lCjÛœÕ÷Nñ‚ûûûÑn·ãôô¬gùîînlmmED¨a‹Ù‘5)" ¨Ò3°¿°}ìc/^xá§Rna1’ÀKD¿˜Ý ¬€vkUW…‘lWða>«´(dÿ| Êæ Ù–BQõ1@(dŠˆHû›™™IÛwY›@³ïåï™ãÜñ_l Ûíæa[Þ£‚N>\ÀðÖvÃ1²¢………šúÇóW‘'=×U‚ Ï`íÞ»w/ɼ§çn4Î@4Vl›ßX+”Õ`eee@:TI¤k×®ÅóÏ?ïÿûão|c|éK_Ê"RYLÁ’õ(=::Iò1d›—.]Š·½ímÑjµâ·~ë·âÎ;™5q#I”!r"o-w¸–@WЋ¨D–¬§ù;oMùh^ç2›Çäzá…(ÌÏÏ'‹]%3 êÈÈHj#íïïçÆ»´´>LF+a#ã´9½FãìÔLemÿÅ Ù<€¯ÙÙÙØÚÚJݪÏû»Ïbé ŽLw,[- äYc@Ê&Z™€¼êâmB•µµ9‘Y`àê½"büýÓÓÓ±²²2 û€p€–£¯­ê¤]{½^FüÖ6›÷îÝË÷¨Œ7fßæ9::: ©v»ïàcŠŒ1Y”M8­‡¿Ø,kFÇ&W$D` ›C›,{—­©ul™MÖÿ¯öO{®óŽMÝç±›î'@Ð6Ï‘ï²<ú@ãZ0WSö‡‡‡9þ0²fjÁ-›ý¦oú×ñ#?òwãïü¿VYÃØØX\½z5.^¼˜®1Â<U¤/lO]Jeuÿaó²)þ<11‘Ù‰ZW ×öææfj›=ƒÂL Ï:bï±··—m4#"»¦°ïéé锑Y×ìC°Xkt$¤%‚Ÿc›|¹¤óØÈJÔGXµß»56::š¶å½CÕ€w»Ý<5–¯Φ"\&&&âòåËÑëõbgg'»åÂ"úéYkÞïôô4ƒZ˜JÂ7??Ÿÿ„VžL¡ñ&ùÈ$nÍ™_,ÿÁÁA´Ûí$*ªÿ3ˆEÃ5Ë_tEzðàA´Ûíœ €?"2 Ë.ŽŽŽbmm-nܸÿñ?þÇ|§Fã¬!ÄÊÊJÚ¿h>ìl9Ön·#"âöíÛqóæÍX__ènvzzšA©fÍÒgÀWëgªtS]‘{žžfà"úËù/ÿ÷‰óëáuæ“ëŸþÓšŽJê•ö·j3¥\µW¼¤Ek$FÙïò^ÕµÚœ‡ º°°{{{ ö° 6ƒƒƒ,Ä«`Za«@AË@‡x³U“Ño Ñ?z<"ÒIJÇ6a2r››ÏyÏZX©Ä‹ã IDATè »Yõýé‹>åÃñ>Làal±ÄRÐ5E¬UZS¿tµÀP<¤lþõ0)6T²3@‚¦ÓÆWµÖÝnw ‡¸¹©}¥—Æ€5fív; :É|d¼#àjLšÍfö_®5lÁç°ôZZÖ¶„‚4)ucm>m2VÝn7ÁfYpÑ/àöÎaY`ÊÈ¸ïææf|Ë·üz|üã?ï}ï¿KY„ô¿¹5&ŠéæØ‘‰àØ©y wÙØØÈµ8VÍsek NyD-¨”qP[A^â¹ÉÉÉX__Ð¥×ì¤ÞFÝ)°¼¿¿{{{±¼¼œ™I¤ýñ0áÀ>šÍfàN'Oƒæ?øýÓòtYvµn·ÛäÇââbf;d–––ÒŽù+Œ,|ÿþý<ÍHŸ™™I©[­W°~Z²²š¥ˆè·‰­Úzë%"H–J~X/@^`„¸`ûÚj...fö€?æãjý”l˜V±ÖmmŒà]iÒ`¾›í f·¶¶âÎ;ñÚk¯%¡${æÚ}hqq13ÆÀ½‘uW[Ez/ßE×jµ ,k[Öáwnû§íh}ÏVÇ\våúõëñÌ3ÏÄêêjÚšù¨ m‹ZÛÓbÍ«Û]]óÆÐY¡±ª{±ýG¯Z#v^en2Föß­.­f\øÐÄw|Çwü×àÂùõUxËl“ëüƒ0P@CŽbCŒˆÔ×T,'d£ÿ£ôÆ3Ï<{{{±³³3ŽˆÔíÑÀòááá@g’ªG¢9{-ý€šÚíQXXuï•ÙðLÒž~†|Dë.rX·Ûè|à³Íf3VWWã;¾ã;âÛ¾íÛâ¹çž‹'žx"îܹ“Ý €ÙÉÉÉL}V–Žî(¨zJiPAËââbÖ¹@§Í@Z(©šq1~U:dna:ìùùù6LÌ¿ ¢à‰Mˆeã¨'ÍV©–q©šjÁ„ùšžžÎ”¹ UQ3ãg=_e¹k esS´¨T¦ÁçÈWÌ¿€À%™p8’Ÿâi¬ŸZ(FDÎ)ÙÉèèh¶†Œˆ>ôìlbb"eXdÀŒyPD>wttæÏür|ìc?ßøÿ*?Xt:l ‹a`“R° rã`þ«î𫍠¸JöÌ™±¬€„m ò±ûûû±¸¸˜€œ¤`¸Ð)¡Ý¦ ð1_‚±vü¨™<ëmñaNˆ­­U&²—V«•ÏLïîîØ~¯×Ë¢Wã ([×5HBø¼{œÆÄX²AK¯×‹¹¹¹xöÙgSŽf™EÅãããiüµµc}“@Éæ`­W߯p=¢OEôÙþÓÓÓXZZJÀïÚ¦²óJöØwøDs933“ دKÙ¡ÚUÀj]ÖÀDc\·¶¶’Hj·ÛY°ê{&&&²@Í~‘múõ3ü±µi?²zÇúÎZiVéšZ&þ¸îç´øí¯ýµßv8¿¾:®—^z)¾ò8Èóë‘»ÕEDn¤´£•5¯Ýh^ö‘‘‘¸yóflll$û[Ó’À2ÇïßÇÇÏŽ5×o‹Ä‘EôOÉ£µ‘u:,Ø]\\ŒˆH ¼t7‡mãªú䈾ܢ‚±ˆHÐ/3È›>‹õh6›qõêÕdWj{²ªY¬¬][ìaÝjçi[mÅ0TÆ5"R·]µ¬À W;ƒ(>ˆ™G:ÞÚ!§Ñh 0sµÅ` l~•-÷,Íf39(€#¬‘B-@¸¶º25(«){`tkkkà„_›—yèËF*ø`è¬Ã¼+/صyúÿfî677c~~~ Xj¾Jèª1fËËË=³×ÖÖRÂåÁÁÆÆF\¹r%cdd$µâ£££ ¾´Âìõzñ‘|4>þñOÅG?ú£¹á¤ æªÆ>wzz/^È6Ôú Ìgħ[7¾º¸ŠÍ¦¹²áƦ÷ÑýÊÎU@!Y{‹û÷ïG§Ó‰K—.¥üЭv];¥Ü5c µ;ÉÂÂB<ýôÓ±¾¾wïÞÍঞvzrr’mR­y·Î"ÞQMìÀÅ‹ó»dæ""ƒkÐ=·oߎÅÅÅXZZJ` ¤ÏÌÌÄÂÂB’o~ó›ãÒ¥Kñ/þÅ¿ÈàÙ³›?6Öµ£ù«õ!jˆ&''£ÝngI•¨ RÛ@þÀ~jl>|«««Y°,S#›ç}­ùš ìõz±¹¹™Åøæ*«Ý_KlA†oee% “VWW3p¬cN>IpÙSŒÿeß³WX«tTÌË^Ûív¬¬¬d`‡¤3U–©`¼fÝϯGó:×Ì?—Ånãåˆ*+éªÚiNýðð0ÙøµµµL=ê–™ÆR#ú ˆsÓ#û HpnRÛN1èˆûKÓ—Úh½cÕ¸º_D_šR¿³2¯‘}Üý⤞½½½tºív;Ö××óßj é?Ï@rX;¿Ì•Öfþ߯ xøuéÒ¥Ô‚WuîÆÇÇ“$ɉˆl«i¾‰gªZmc4::šŒ}ý,€a“¥Y­¶†UU ]e@4æË]7/½Ò$m yI±WÉF•=ÔÞÔìÒ¦oþQ×y6kÊL`÷+È©€Г}`ëž©Óé$HWíµ9Ç’šS Ççe(d7ÚívœœœÄ'>ñÉø±û{Ñív“ĘÖ@Ë8ê8Ru×Õ~+Ž=¯ö€1ö\µèºÞC`Ñ×NGÄWUóóó øÌ« Õó ìDµ0\ïÞ‚Ïa>0³µ ›] ð%².ó/SF:§±€KpÉ/ ô}2…½z7uMjEØ„5d»“““ØÙÙÉÀX&E6¤ŽßÆÆÆ@³ß];¾¨9àƒ*kîç0Ð5sr||<ÀÒ Feî¬ckÏša(TrÄŸæÕžü™Æ:‘PàͰ٪¯õ`ÕFô²æ—/ôܾßI¬²‘Ù¶PmÜ8ñ¥ZkÚ‹*Ù`ÍUÉ¥ï¯þ©î'u-_öu.³y ®OúÓÉtÚ±#‘)ú p«S´OƒÁŠDÄ€3âÀ«–{Tõƒ‘ºÛá6]Àéæ0H}ÇÌGœ¥¥¥Ìè|QµâR™¸¦cxûöíø­ßú­xå•Wâ—ù—ã•W^É B(«,¦­ÊøÛS}‡ŒMÎ,ùêêj¼éMoÊö6z ‘VÕ¼-//çܺâhgi7@©v¾ý ˜«< ×ëÅîîn4›Í|g`êÁƒ±»»›ÙàÀ†%pÁðÉDDJ °½µsÅòòòÓzrr2Ð^”öºÚ?yËÒÒÒ@Àgì±vSSƒG¦W ðÀªW¨Á£`×ôÞ0×T¼ïÔ`Z\\Ì÷–ñR÷Q3ôï<ˆ÷½ï3ñ©O}2Þÿþ_M&²¶m5¯¯Wû(“ y.`¡Ú;0$(B x>ÒŸìhcIrP³ZØv€Rà$Û!Ëe|¶¶¶ že­h‹Óöø?£ö”õçd@Lï¹¶¶–À[¯ýíííôo½^/³˜•ݯrŠ:~ çææâü‘?O<ñDf2Ø›±¯Ò ÏÈþ¢Õjåxìîî¦÷ûØØX¬­­ÅÚÚZ¼òÊ+ È=ŸÚ÷`еßäÏj-„5,øæeÌ¿½··—ÍÚÚZÞ³fRkÀn_pòíÜÜ\ÊId9Ö×׳ë™õ'X³öØUÕÝ †ÙI£Ñˆ«W¯&‘ÑÏÊfɾUf¼‚nûªÎ_ÃÝÒìÇ|Òòòò@¶ãøø8ƒkkÓžeÞe|ýݳ.ø¬£££ø+å¯üþÀÃùõUqkæ“ë§~ê§R£gã Ù899‰ÅÅÅdgl¶n@@e—kðÅ(DD¦ô1 IÑ"Gúptt”à„CRPuxx˜ìIu–wD$ð¬ j‘'†;C¹Yr¦dÇÇDZ¾¾÷ïß;wîÄ7’ÑÄR%pàªäC«CÀÃkªYcr ŽÛf\;øÐøÚD¥èeP°8»»»µÇ©úሾ\8L€x2“™™™œãe.wív;åž¹vQ¡ë–™Í¢FØZHL'kcµ) "lnl `k¡^l¡¡›%‘ÂhGDv5qöm®diz6×ëõb}}=ÇM‚‘‹èjW‰DíápbekÀyùòåX^^N 'ÐýÆoü…øøÇ,Þÿþ_M Ón·£ÝnG«ÕJ0†‘ø ,""Á¬`Ú|b«ëgУ£þaaoÜÅææfþlͼìîîfÀaj–£â +q 0ª‰ Y™Fe7Œò#왼F=ƒñà°»2TcZA Ÿ±¿¿—.]Šéééxê©§â/ü…¿ïxÇ;â¹çž‹õõõ<Í”Wɱè):¯u §§§±¼¼<à/{½^´Ûí ¤É®¬¬?9Œy7ö‚l¾úõÈ”Z dkÀñññ˜››ËbeRKòÆÚ©iee%Ÿ“-,--å÷Dz•d†Ö¼1·°°‹ºWÍÌÌd¦ƒŸªõCÆ Œe[Q>¾ž€S¿AÒèßù«ííí òøÒaß";æÝÃl–ïà¿øíóC£Íë¼5åcrq”µ…\D¿­ŸÖƒE…þßUÙ7ÉpËE›Ú°\ÇÏ× ¦¶A«ÿ7ÌXVyM}¦*vþ—ÍÓòzlèð»×öwõ;½Ëîînj.ë³ø@¥þz½6…žCªUw˜ÚÑÅUïá]ô+®-Éêx“½LNNfª^ªÛ|ÍÎδ~Lê/2Ÿ¯ ~ÙUÛ…¸ÉÂÖyžKý¾Í£NîU5ÉÎáˆU²ÁëØxfãîßÙÙRÕà×öt55節%ë8¸Çp@¹°°vg¾Uí———¤žÅxnnn؇Úµ¦Ó9ëi½µµN'~è‡~8~è‡~0ÿ}yy9.^¼“““ùóÃóXå6jrƸ®cAo¶åÝ5›Ue$N'kPêU6Þ¿³o÷ø½Öu â<—uÀžöTíÉs Û«1ä#Ì“l˜ûª+©þÁxÕ‡æ@àm.jk]A}•Á _Æ¿‚ORžaßR5Üž¯úIcæ»ëÚ­‚g¯ëiX"óàgª\Ò¿ÕŸóLÞ³þ¼ÿ³ÌU“Ú½'"¢ÙlÆõë×cuu5ïÏÏ×lã𽎎Žrô|îËnŒ‡1¯¾Þø´Z­ô¡Æ|øsl¯ÚʰÝÕÏÕç5F>1è‹Ý÷üzt¯sfþ1¸^|ñÅdºµFÄžt»ÝØÜÜL¶;,Í,ÕªXPº·ÙlÆäädv¾À®cU&L v °9`Ké];Nj¡#úÇ™cE¥Ä±ÏX-ÌŒˆd¨‡°VdÈæçç“7¯µ`—M^ºt).^¼'''qÿþýx饗òð8kÉ ¯sss¹6|çáïdòØ L wàk7­Z„éФ×â;2-? K'c<·@ ûè(š¶YÑГæÊwJ?ñÄÉÄ‘‘x¿ÍÍÍ òŒ;1cccÑjµrœjú_-‚爈¶²ÔÆYÐAZ"UNÿÜét²€MÉ( Lœ ëÿ—––´ä• ˆœ‡Z{P%ëŠ Ì¼³ÀZ0ŽŒŒ$Sïy€i )"²eê§?ýÓñýßÿÃñs?÷ó„x&kroo/¿K½ ÃºÝn´Z­ØØØ`ÓÙ„–°tóÍfs ;–5jîÙ9ÿãø `ˆ³þe¶d%—€qdKÞÑzëvÏŠ•÷÷÷css3._¾œc=>>ž>ø6Ÿkkk±´´SSSÑn·ãòåËñÚk¯ °ÿÝîYÇ¢zŽÄÑÑÙ •ÑLܼy3}Q¯×‹/|á i{Ö–v‘Æš¼n~~>kD°Ïív;³\+++i»{{{IêLNöÛÆZ+ºÐüNí´Òhœµ´­`ê ´È„Ú6³íD[Í""Ò&Ïà›Íf® Á2?É—“7™Lÿ­[·â_þË™l~e¬íQGGG±°°ËËË™y%“ìt:YÿTý^õ©Íf3mzii)k&ðö#ßÇ·Ô °=LCÝßdzjÒ~ÁÖ¬q¶Â—©/;¿Ý뜙 ®^x!#sÕfdaÞhNkaV• `?€.Ž6)l¸‹GólÃÕa ¢¯SW¨£õ% ³çs6!ŒzD¤s\XXÈ÷¨]R0:+¨ïȹß„` 6>¬’ûØä߇1’9ÀÒdP‹=kOò ²°AµðÊûaúö÷÷,×îÀ†È,a‚€JG³ÙL×s?2'A¢BNÅ®Š×êf X{_óÀ¶Ìk·ÛÍ^Ít¥Õææfôz½X\\LPÆ®ÆÆÆ²c†{'ú\̯ï5æ±ñ4Þ€*c¸wï^²yì²ÖIø3ý{·ÛÍÂlsxrrÛÛÛ™ñ±‰ÏÍÍ%‹h °OºX …FÞg=»ï(GFFâ[¿õsñ7ÿæ÷Å>ðùXXÄn··oߎˆˆË—/§” oíê&„U°,+"€Ð[ãl.°“f£ŽwªÅÇì@0^A;¯Ý̽ ”ÏÛßßíí혞žÎº¶d-øn>ñøø8k=óU}Ÿ`‘?V«•Y@ ¾ŽÓÆÆF¬­­ÅÝ»wó{e6°å°©ÚÜÜŒf³™6Z}l=Œˆ­ =5`·žkP…ñUc!Û¤K’àNhu8ÿS"¨]Õ ¥±·N}Äoooç3>xð`àÐÂ8Y÷{{{±µµ5P[5;;O=õTœžžf‹Nó&èüò—¿'''qáÂ…èõÎúô“ÍØC°ìöXÁ€ìÔäädPSSSyÞ€ïaÇæÒýdÜø ~†?¤ùW\ï¬þV× Aî¹fþѼΙùÇè’"Žl÷hCÅV)Ê©:ôˆ`ó}Fïîˆ>³\ÐhEæ;+«‚éÂàaˆH&8cÅ›>qàølÀk"ÍË™Gô7Œ‰ßÏam9T,xeý6‡œ`Dôï®ãhì´ó kê¾²ˆTåÌÌLþ_Üý–šUú`ü«óbÜêˆÛ8ë …l‡ÜB± ñ®lËx^5;$xo rbb"ƒÅÚ*Ò}¥²‡.\È<¢ŸÙ!¨:_©nöî{GGϺæ°©ú¬î/è±ÑëS³4ؼ´øÝ³U€gÎ*ë(;5??ŸÅ‰UâA²"pÂ’Z‡ÖõÅÎ#"ÀOýÔ ñÝßý·âþ߉ˆÈl“bùÚ«ß³Ö>í‚D@ Ä”Ö5/˜T ,èŽèÅoø:€¢°“$ŽûõàÁƒ”(†§§§Éfæ»4›Í,d㕨Á­LV=ćæšlGf‹ Fô϶°v«. ¬¾Hð‡T0¦|*ÛŒ”V9—,¦-5C ØqÚ•ˆ[|”¿×ñ®¶P×”Û©­.*I¦¬›`¬®EAuìüRÌýýý,š•ÝõœlI€nL»²U_}m^PíR¥J¸üŒ"ÙÊô×€Úœó)ÆN°ËÌOµ‡z)6ìÓçø cí²ž=Ó°Öþüz´®sfþ1¸^|ñňˆÔFD²©€HÕBIa t•*Ôb½ˆ¾¤ÀFY[daD´8ÎÜæVs¬`é~þ C¼¿¿Ÿ@UšVÚ–ÜFYõ‘XÌV–¤ÃÆ.Kßqtœ6ÓÚE`cc#ml€H Õ°^¾²0î_ÁïõÀe}©m€Pð4ŽŽfÿõúsžIæ#\²ßY»GØ€<“_5ðòûp?pàP· 6VûHHãOMMeKIÏNÎf«¼ƒ×XcKmä!F#666´ÀUÎCã-ˆSˆjÍ`}k=‰¹f›ýŽ6ËËËÙáC'k˜Öãâ+[:==s®Vƒˆ?::Šw½ëßÄþà߉?ûgu ëm: ù»6¯Øi€³k-üÞÅs.,,äš«,={¯õ:ÞÇy|ŒÚ'jÕYA%1àã:´lãôôt¶'åŸI5;†ñ<`¡ﺭðGdäëõÎÚ1Žep!0ˆèDÆç©UÚßßÝÝÝ$;Ôí°{²j—%kØÿÕ6¼Ö[e†µ˜U¬,cKlWLeü7æ-"Òfýl•jMNNÆîîná³?g˜XOlvvv6[ñFDêÙî$ôgkÄßcr y{{;÷êSÑÊÊJï *oëÁf³‚>¡Ú³ý¬vüªš>) `á‡Í+ÒM£ÒöövgÙ™}èCÿ]XâüúÃy·¦|L.°6\L Ë"½(º¯ì76cw||< ·­ŒZe¦IOn²:m)VŸÍ“újZ¶þ¼Täf³9vÉ æææ²0×f`Ö~䯝iöZ˜«û6ÊXb×Ý«LÞÀ³apèQmX´ïœ¿qõnµ/³ qtt4îÞ½;8qðããã96R8-g•CU¸ÀÒÖ±€P%s L° ©9ªi})h@žMÓ˜Ô^¯—L° VUf¥.ÓËÎo$æÉ‰“˜1àÂüÚ8m”UZV tIwHŸ|’EDJ¼›yÖ¢ntt4k :£µµµØÞÞN°å™Ž±©Æ2 IDATŽRÃÎ>õŸÆ(Zcï~÷¿þáŠ}è·³˜Ø: wZja$yV»ÝŽd!l@ƒ+jŒæjUÖ2[\YYXGŠõFA{ biÈ«™/1®ü_ ø­o6äyªDÌzÔ]‰½cB­]R ã&p¬ò öéß­[ëÀš®rF ˜õŽ;;;)3«à$ªfÚØŸ +Á'É$MLLÄÆÆFú@ï;77—Ù2>@à_s#`ÞùöRýàÿðáÃ<Õ}­;vÀܼ²é*ɬ™†íííô™:Uæ|ff&?oüù.R?vĦ""‹¶ëi½ÆÃ=e`|VPTý’ ÝûWÛnÀÇÛã ¤TìC#ÓþÁ~ð¿ί¯ºëÌ?&×ç>÷¹¶„ê­*«; ŒêI¾¼¼+++±»»›:JÀš„ÓÀØrT´ÑuãÀRs| ˆÁÖDDê~#"Sé˜Ul5€ÉÎ`£ësWM¾{ÆÎÎNvŠ|«æ˜–‘üH©Ì·´žÐøðáÃ>žlýƒ²ƒç$ÉÕvwwóß*«©^ä=ŸK—.¥†]€„øyE‡«««ñÄOÄÒÒRfßú­ŸïùžÇ7ó/'ÈQPÈvM ^ á©©©<€tÉ{ñäüÈŠÐî7›Í|Î .Äk¯½–ä‚ãéɇtQyøða4›ÍÔŠ[÷WÃL‘ÉŸüÁÆÆFÎ'PΦÙ+… PÌMÆwµÛíÌ&T‹<‘UÉDmnnÆññqλÀU0m~j"s¨ïïïg±l͸ԺL²ìªy"o‘uãeJÙ¨,¥à˘ÕIý.OÆ8¢D»€3›ö;ÿbÜ̧ÿCÈ&!/hàbr&ÄŠñ#ƒdü$û óƒÈ&>_kÜ#bà A@•™¹¹¹:†š07æ¾’ì†&ߨTÂfaa!×Ò… booD¯ó>óÉ%%б¨#²¾†u½œFM¿cgkÑžÏúå{ýLÝlôRÅ>ï—;öwÕ~éØðúNþ X¯÷àôfggÓ¡Öçö|õ‡ÇÔ½kÚ_ ·ê2NÃ=‚ë{#Ï^µ³N'–——£Õj%8©ýØ=« #í†Ç´>C=v=¢ŸÕ05sã½ëX™ŸÊrÕï0¿ž·¾;;ü\e­}¶ή­­ |ǰíÖ NQÇÛupp[[[±³³“L÷7žlË=ôjß¾‹ýºˆæM·ÚÐØ™oï_Ç´Êe*ÃðÊY—>_;¡ø·‹/æŸÏòùô§:¾ç{>œàcx<ëüT]xµóF£‘í=­‘š©Ÿ5ÖfW¬÷ÚÚZܾ};»õÔûºwµ-Bdd ê˜ Êü^ßuø³Õ¾ª²ëaûc/µ ?Tû«{ß«x«ÕÊqä :N¶2e_¾ßÏíïïç˜ÛÃë»f­\ÖÛcWuÞÙ[=kbø2î.¾Ä;V°Ym÷õü«çÀÊ›+ö\纎ƒ¿WÉQ]WÃsyöÂÂB\½z5Ï›¨÷ò.Þ£®å:6uÌêþè‡{ÚÛt©©ë¡>¯ûÕÏ»çðç<“9°/_îuÎÌ?×'>ñ‰X__Og¤C€n%ŠŒÕBTÌ+†ýîÝ»±¿¿?°ùjM†Ý²Óì‘3prœJ§ÓIæ ¤gqDŸ‰è·|Œˆd6°mØpÿH¹kÏWu¼œ¯T1ME€´‡x¸0ŸF#VVV²æ IajA”ŒCÕˆW¦k{{;Óîív;µöï{ßûâÙgŸÍVu´â˜2€ºqW–‹6“e:==MéŽÞÍ25Ƶ²Ø½aÙæ »ÿðáÃhµZÉ bá½?í²ï¢®'½_ÕN§“ºy¶DG½½½ìš3m¸ä샤 s[3KUgì;±ñU–``8eUüí<£Ã ­²g·Éïìì¤-«M`²»»»1??÷îÝ8èkss3ƒ:·ØQlŸq”AÚÙÙIôýû÷@|ã7þ«øÈG~$þÔŸú Þvl¶û˜+é~­#úYª?99I3fè&u².tÑÙÚÚJ)G£Ñ/FÆöÖ  ¶•em%«Üȸ²YÅ’Ö()„ À#{a»¾ÿèèhàôUkÙšÞj–Pf’í»É[¨ë Ð3–F#ÇP6ŠÊY|útc‹íÆ€#F¬uöYk^øµ$ƘMc¢«üϼxþ 8IüìAˆß¹¶Èþð£$7˜~Yˆþ)ÍÎ$‘¹“‘±4÷qáÂ…xþùçãOÿé?O=õT¼á oˆµµµØÜÜÌw>::JÿÂÇ{Ÿ1—æŸýU­¿`ÅÏ;³Â¸`ä7¿Ä¯×,{ÍV«]°ŽÌ›®SçÝlÍë¼›Ícré `C¿zõj\½z5^~ùå¸qãÆW8VÀpzz:fggSö ­Eô{¶sÆU³¸¸˜¶n¢.õšz›//eH‰•jÁ­´6Mv§ÓɃ6|^Ïeò ß­3Š€€1¢¯ÿTÀçP›ýýýv6-À#"2à‰8cÂïÞ½›Åǘqšo`Uñ”vÿé?ý§6ƒÚ|Ý&-ð9¬S˜/¤6}}ŸÙÎòòrÖTÉ“aü\íø¢`«qvŒñ0öìMñáññqlmmå&è]0º[@“¿v1lFP·ººš ±.-- HSl¶6܈HMª 3«óŽLX»žžŽTDÂàÞ6]À®×ë%@þìööv²¿Z×qæº×ë t·Ôê×¾··—2ˆüŸþ§ÿ9¾ÿûÿÇø™ŸùÙÔƒ“¶8I¦˜$öFfF~øÕ‚wAPµg’+Ÿ­{ÂÖÏÏÏG»Ýö1ò333(þ¿ìÝÝìëUøÕU]ý^oݽ»ûlŸcÇ8ÈNœåÆA`"@"¡„r›(Dɘ Q0^bÈŽ q˜p•? 37#¢™d3å(\X±,çx{ŸýÒoUÝÕï]Ý=}>«V•A¢¹À{÷OÚÚ{wWý~ÏïyYÏw}×w­çöö6çv-ïh°sì›< ó ×륰°°²3št÷°«TÁÇ’ò! \÷ÔY+ëëë™ëÝ$HJ^·Ž–——ccc#^¼x‘v—ÓÇ>sZ9ì•{±ë¯Ú$ö[’ìòòòT-zŽ¡ù!'„3ŽT19wîÉIÁ(gßÖÜ öYô‚m7G´Ÿ£©ïý:¶o½õV<~ü8>ùÉOÆÖÖV:%»»»q}}v×Þf.*ŪŸ8c•@"G´®Ù\6h0ÄææfÎM’­ZT™R ŒÇ㜳l}³F5kÞÀÃõê^`þ5¸°µ)ÚÛÛ‹ˆ‰‘®ìzDL±W5a“ÑÂ’c–""u‘›(ƒ+¬]ëÔetŽ7&%bb¸êûT'¡&Úh«­mgä* £o¶YEÜU ¥ùŒˆ|a÷¢®›LÕ•j;†ëæªÀGBPòüùó©È}(öǦTYx`Þ!5“ê úSn¬ÝHª>c$:`ã¬lðYÇÌgUÇ£Ýn§³À©‰ˆ¼·cî½›þdªAà1ŒÆÓøh[D$cGO{yyÇÇÇSÿ7×mÔ"§Tÿ{ÇëëëÔ럚T¼´´ý~JŠRË£šçòê¡0”¹Sç‡Ë¸Ô±P…e8Nå¯hC·Ûßøÿ5þÖßúÛñ™Ïüb²¬N÷\õŸ\€pmm-ºÝn® ŸUUi1)¯Z“æ­s²÷Ž”¥¬R† JOOO³¤¢ŸÕÒ³ýŽ|àìDduÎßÜÜWº‘Qíg_ÕkªV•ñ{l>ÛQ±¾¯ö³^œ|ó6;6¿2¾dÕ–T»Y׌¹Ê~Gí¡Ù®N¦uÃ6q’±ñÆè§û9t€¡÷ÝßßÏêHæaí£ZÁìîî.`Ÿ'‡ëv»Ñn·3gL¿---å|#'}©’Q£ÑÈhû"Â}ëºç²cÚïYìAèX÷ªôÌÏÏçmÖ&Öa|¸^ÍëAfó\ŸùÌgÐÓŠe¸²&9ED†ÍUOº$"’Løžÿ30•e¬’  Æ÷vww§6ÏØ{ò›Ãlƒ™ÕwúwÝÄ•­ªVße=GÈŸ¼pVÅ£²ÕØV  ¼c=ÇÆŒUö,I¤N¬ák!lýÉ’´Æ ÀUMp= µÑhd5…N§“ŽÉ¶«Ûl6§ªÈˆÒèg `ss3Aí?0‰aÅú]__Çæææ”œ*"2ŠRç¤ÊB· xô ,‘’¤HvÙi·ÛyB°¹ÍÖæÇÙ“(º½½?ΰµäR}D‚xZ'777) ªQí1ÒXõ:Wkß7ªüƒÑît:Y¦êíõ¹gqÚ<‹ô@´èðâÇ~ìïÄw÷ïNÍ`ƒ€%öœzÿˆI>ÅÂÂB'ð­ó@éÓš^Áon¦K*Z{WWW±½½FIK`°"Gâ”v:”FÄÔÜ&S©ò»áp˜kp<¾ÏmQm…ÃôœœdŸ+Kyuu0’¿ª“Uí±±«@˜cÝï÷ãèè(—––¢ÛíÆÉÉI:§l*¹]£©dEÞ»Ýn' ô½ÊÄ׊Oª«èGk–ìÊg9&Þ!"bkk+vvv¢×ëÅÁÁABe˜?õÔ_ÀÑÂ~6L¬®ÄŠ Võ¼ œ=ÙÞÞŽ}èCi»¯®®âóŸÿ|üáþaJîööö¢×ëå¾âÙl­=ÏÜR’ôúú:Ïa#êÜ–·âgl‰¹%J40'«FžÍô¿Sá©×ëÅ_þËù‚ ×7áõPÍæ5¹>÷¹Ï%XÃ6B–•­­!ÌZý@Å€ ¤«NWÊVö¨‚]ÕHi$ Uö?"¦6Ve én1¶¤16¥ˆHC­í˜l}Ðív§ôËŒq=*žFÀú kòQ=BÝ&eó­eÕe kÜÌMƒõ±ùTgÌæÆ1Y]]ÍÍYE ªÃä T­¿þ€P’²‰ ¨777§ò0ˆµtcDL÷îî.° ¯1¡˜9ÀOdgmm-æææâèèhª¾5ÆU½ÖôèQ¶Ñçj_[÷§KÒòÒµbÆÍSÏÔ¦ííí¬Æ³²²o¼ñF|ä#Éë›››Ø5`uu5«—lmmåܱ?IyæD¨\bΜžžf´KäÀøbó°›lgx»ººŠøÿ?öc'¾ç{þŸ”Aq’Ì­š`>Ô(N­>€9áU=}ïÉIᜈŠÐ[ce>ŽÝÝÝ)I{&šQû  õ½êHÕ“E²í%F#«);Y%S@|­öe=²}Ö<ùçù¡šÍ«y=hæ_£ èfpm꣈é‚54/dŒÍˆ˜”ÁªRŽ Ã˜ÄÝÝ]&Ï1¢X#QpÍØU†W-å ¶…&¯®®2¬_åBëòlžØãV«ÛÛÛù=ïHZåC´ûûû ¨Àh1Ä3cF†Ö@  %5_¼x‘NÈááañªJlþ³¥-çææòtP̃_ÔA®õ iM]5¼<77—c PÙ k¥›· ™Ób£­É¸Æ?bRÈXrÖ81÷¬Pq00°"6jNŠ9WV^=om°Ad/_¾ŒÓÓÓŒVé¿5¡ÇqppïisÖÚqïD˜+ƒÁ ×d£q–@»ÝÎH<¬^­`aÜIÚ8ëÖ’±YYYÉù«ý5ÿe<ǯÿú?¿ý·ÿ~üìÏþ\®)%(9Ž×p8ŒÃÃØŸŸtZjÙEŽ !ʃùö3mÛÚÚJ–µ:˜"XÇÇÇɯ¯¯çùN'ò=@ˆC£„_MB5w»Ýn:F˜R@“ l‘0J€¬R»êLT)Þááa¬®®&s_×"§ÓjµÜ§q0Æê²sâ?÷äsØæææ2 V sä 0X‰ ¶Ú¼[XXˆõõõGŽÀââbÚ´ËËûÙoÉ«œ´ƒƒƒxñâÅ×Uع½½Mgpww7÷§ºGpΫñ{}%zq/ÙÛÛËèÞùùyìïïçáQ" £Ñ(ƒAö¥\•êHr†¬]ö¬¼¥Ú ÊkÉOçU°Ó÷9úiÑét²]lüÊÊJ:Á÷º{Ž"‚êázµ¯0ÿš]À` FLìNv11“Rp@¯M àcLÈ3""ÁŸç£rlŒ# èV ²{ED‚ûÙw³i3º>ϰUËî}°u˜v ÆÆj3Äb£È7|ଲmb€½‹ÏÙHµW¿OØyØìå0.ãSŒ#£V@0´x˜T…¾+­¥Öêøj?ðjóöþ6-à>ÕŸ6ʪµ¯ÑÌè>𸸸ˆ£££x÷Ýw§t½õ@anrƒýýýè÷ûUÐ76aÀ PäbÆãq†½XòL»ÈÌ•*Ūцšᙫ««Ñï÷§Ö*Ÿr_ã]Ë“Ö*KÖ~•\‡ÖQMZü•_ùÕø{ï§âñ—’õm6›±±±‘߯Ò6óc­mÕY®ãTå`ÆÙ\ñn5qØýÍ…ªg>88ˆ'OžÄÍÍMN­@°®óº=£Pó3nnn¦} (ú.‡®ê£ëWMýléW:ñÚvýPo­z£=5Rº¾¾>å8«Äž÷Ö^¶MèÙ‹ŸKº4Wª|Q?±åª¹´õèèèël¹±˜ŸŸHCÍ/¬¼yêwưžV« úÛ\³xï¿»»›Î›¨S­¾†4Ñ'ÚÉ™á$ÍŽ¹ç*@ŽSÕxDÌM¤3Õ~Ô{ëŸÚŸµA-‡\óH®Wïzó¯Á%lÇHSTV€†y²AØôÈ jH²ê#"¬ÊXÔg¨ü@§mþ<Ó&`CFÉÚ1À¢ *hhƒÏxozàêH¬­­e!F§$Q@ {ncÄ^“¡DD2„@:#\ªj›MUR˜öcÎUÄÀЫøqÏØ¸OÄôa*.loDäWúFB¬ü ¿ÂÆ\ꌑþ­@-©Ÿ°œœA§Jʪãæý*8Sk‹Íµ1Uçnuu5~ð0ÎÎÎâ÷~ï÷صQB6 Œµ’lm^GDÊ’•ÅÅûSN&Ϩ tÊþú¬ê/é³³³L¶Ãì:ž–ß{r:///ãñãÇñçþÜŸ‹øÃñÅ/~1¾ð…/DĤ äééé°%ñªzôšðèy)­¶þÐçgggñ3?óã'~âÅOÿô§SBw~~žóggg'ÿRÍ[H¿[Ÿ¡ÚèÀ•꣓%ϱ×ÊþŽˆdm% ×j8“ÍŒ¡ÇxÑë’ŠÐ|X`ýää$noocgggªs­ˆ‚±´©s*‹iœé=±°U–¼Ø€ ¢ˆÈ°7f®ê»9?6âáp )éF ìm‚6T]eÆé?õƒBrmðúìææ&ƒA>ã\CÝ5Bac½¸¸H`4gÀ¿²]ûûûñÁ~0çX«ÕŠÝÝÝFYGóÍé4wÌá*5kµZÉ.D»ÝÎ*BÀÒÉÉIjÒÉô w»ÝŽÃÃÃdïîîò85@¢¼ÉäÖ„u%án{{;>ò‘d4ÌI”XrIr÷õàF¼|ù2å*$h$Xúbnn.:NœžžF£q_dgg'ç“q»½½_ø…ÿà|:~é—þiŒÇã¬öcþûåá8s²Ø %#Í9óØ}ä]è Ο¨’>#™bkúý~¦ƒ®"ŒˆRø1—¾*Írâ1Ðή‰Z’ÝÞÞŸ ±³³“NbdU „÷õ=lwÄ}ÉÜáp˜cÎ Áûà_íK•ü¸Èp$j7¿æhôûýL´_[[‹áp˜d 6!‡ÃïkR+ù!ÊV‘¹±;<7›÷gl ]äP°#ív;öE„ìC¤aµÔ¯q®Õ»Ì7ë–c„ÕGì¨dmss˜#ÈF/U‚Œ]îõziï+‘#7¡æ¢u»ÝX^^Ž÷Þ{/£M¢æäææfÚ«=Ð|­Å*jÔ­V´z¸^½ë!ö5¸þÕ¿úWi0•£÷–Ø ´§Â«X’ªÇĤµ-7£ªv%z?s¥2ÉUÞã3•pˆ%&Öñe3Ø<ë¼FY²|à)¿j6›9¿€)Q[_›V“·¶¶½^/á6”šÈq_Ç¡WŒ”P,ã ”×R÷rÕÊ þø^DLÉmløŽRu [9?ïa#-à x'}^7xŽ0MâHÖZÎ*` <ªJ´ºº=šJRålØüªÆ;»´´4ÅÜ ýËÀj’qŒF£,§'ì_™zU°K¢+5òööv* ¹ö¾¯À©Ýngš«§RÂŽSÊññÝN§“àÙF]#NWýD fܪÞ»ØØxcbNhª¸Íë/xĽ$ ÃdFD2×¢ ¤$ƒÁ ƒÁT5 Üõ¿¹}pp~‰ƒÞY©UÕ–8—ÞµFé~ù—%~ê§þ§¸¼¼L{` µÏýŒPi®Ô¨vTäIÒ¥5 Ž8°n}[O®I;â³Þ›^+Ș׿9hm°UÖ{­ND.!oC™Èº€þ‹‹‹td€\6Gµ ‹‹ûÃáNOOÓñ5¢ E·j¢«u{rr’óéÁ^­­­MÙ˪'g¿õe-÷ª_õ±h ™ GÊwkĆœ‘c[£dl5S?r\ ìj%ªÄÒ~QËíŠêy¶µYtÍû*#ä¤éƒYÀÏÖ‹ø²wÈ*%3WÙ4ÿ¶V‚«îÚÃÞTM|r’~£¼„‡ëÕ¹˜ù×àúÕ_ýÕôîéýh4k-c ‚ÃØØ`i,†{Öét¢×ëe‰ZŒî˜áò,L¿ïìíí¥v¸²V@4PYÙ’š”T7|íväd§Ò‰ÒŠ×CwllµtcÕˆ×ÜZeÅóÖÖÖâÍ7ߌO}êSɰÙ<é…U$Ñ÷‘ýx¤X>ïR#,Þeee%ºÝn ‡Ã‡¹FLœ ›/¶ˆÄ†S'aÑûs¼«ªœ‘~¿ŸÏßýÝß—/_f‹¥¥¥dk¹O oqqq*!UÿˆZÔèGFØÀkN6›ƒEç+zQKÈÙT#îeë[Ãÿ•¡åÀ@d]sñùZMhee%´]ÂX IDATˆœË6~Ò²……ûÓ@ÕÅÅE¼|ù2ööö’YmµZSzj›|³ÙLP3wCщ…5 =b"¹’œwxx˜æw|Çÿ?ÿó?ßõ]¿“ý@¡Ì…»»»¬œ¢ GGG1IHÜßßÍÍÍ\wUÚQ5Å£Ñ(ºÝn®kÎÜÚØ.ó®²°uÝ‘ÚY¾äÆøÔ§>5%g2‡DF£Q¬®®fÒ5@ËAÅ ‹6#Ä'¯‚Çn·;ñAlµZÑëõÒŽr¦DŸØÀ¹ðlŽp'Çâüü<óû2£"nì[trr’s£F|9lhÝ/¼' ì¾Æ¹kÉœ»Z¦×«NNN¦êæs}ÍUMÇ8pz«ìø6_ª<èòò2 ±*=k·ÛSqí«ˆH‰GD4Žmä Õ \½^/Þ~ûíøøÇ?žDG‰Á6ÚÏäVhUg×Üÿáþáÿ~ ñpý‰½êÌ¿&׿þ×ÿ:.//“ù–À%ÜÍ€FÄ”TÐÀò’,Ô ‚À:©[µËB­4³6Œ·ç`Il6S²—*a”#"Ù4Ï%ÀÈ+õf%kÀˆDDˈ‰>8ÁªÐYÛø•]ÚÇ´ÛíøžïùžøÒ—¾ï¾ûn²D•­aüm,6YbS±1êך{@¶tuu•GL>r¿Z’¯2lú`±ñÑë3ìš6Ù,Úív¼ñÆùþž äG»Ýž:úÝœ©ï»¹¹™›½òqkkk L|ÐòvH͘¨Ò Y p}} ‰>¶–sü8”U ÛhÜ—EMÑ/"U&Ä9«0oDv*`Òvl«äQCýžûaë8Ï‹‹‹™\+ÁÓ7??Ÿ ¨>ÒoÚ¯/kdä;¿óßǧ?ýÓñ‰OüïÑjµb0d„”¡2—ære¢Ûívt»Ý\cl”5X×9;ð±cÀ€HŽÁÉÐv÷„ü¾Õj¥Î]'kãðð0...buu5öööòÿ4÷Íf3K„’ëx–õPe»¬uó‘#W¯:?¼;g”Ýd·µ÷öö6«^Õ»_ç§\«–]ÔFR±ÈêÆÆF·Y›Àá7—rc}}=UC~{{(bÀœ5_D ¬'šwó¿’=¤AÖ¦ùÌ‘¡Œˆ,õh~Jz­¹R“3CÌ={\¿ßϨÇZ¤Ã\㤙_ì·5g=pÊ9äòboo/{ ¼¢±5iÝ{sÈÌóã‡~è‡þøÀááú¦¹ÀükrýÆoüFn•MÁÏÕèÒÓøJ¨¬És>[˘ÕçHc€êÆzvv–›4pÌÚ¸g›5IB•Ö`8%UÕ«O@7f Û­ Œ P‰…êt:SU+>úÑÆ_ü‹1AóÞÞ^ö© ûþå/9ž={–?×¶*7¨,u£Ñ˜’HTåÍÍ}E ÌVMÄz0´µ9?@•zÜÂÏÏ —Í àvÀWM>»½½õõõÔ½b¨1½"%dNæ0Ö×׳O|ÓØn·˜aæ†Pzu€$žš·ä6kɃÀ!§C¨ˆÒüüüÔIÉóóóY1DâÑ£G±µµ•›y•:ùÍf3«½pBq@£2óÄéË^¯—9ÆÚÁi•Ý­2í©Ñ+ ³µ\×fDdôèúú:û™þøêê*ûõ“Ÿü·ñ™Ïü“øŽïøwS9Îæš^¼–ݳ¶ÇãûÄmëÈ©¨Æçúú:¥6ãñ8“³#"Ǩ«Ò ðdBÞ½&£*â`:Í{6íéÓ§©ß¯ ­Î÷ê„ÖÆCD”¼ÍªÒ!¹ Ö1ÐÎFÖRŸž]‚«««Ô†ë?Ž?'§æJÔ9Á>q@ïO¸å˜öz½ŒfÖ¨•ïGLêÔ#uØ•ˆH‡·&ÞדY1Ó5Ÿ¥F¿8‘¢4€½H‡ÊÞ@Nçžd”"U>g°‘æ ÛÌ!aw€q̺qaw´Ó[s ""÷MóÅZCÀp°õé{ï½—ßE°?$P%dØŽˆÝp8ŒýÑýÿ V<\‚®Íükta›""‡»l 6˜ˆI¥lÞì÷°Ø¾oƒò] ¶Üçl¶ØŸñ·?.ÏûÉñxŠÙ¨Ïò7cøãE«,Ë}|?bºÔ¢Ë󵿾_DÄÇ?þñÜLÜë½#2-w}† „“âÞþ®ï>«ãÇ2W ¡>v<é:¦>[ûbuu5Á_}¶ÈF}‡ªS¯s)"ò–ªåÔVU""Ç¿¶Ã†4??±¾¾žŸ›u\H8µÿÌÛˆÈïø™~©:TãHŸ¬ÿ|G?ølýw}WÌ¥w1ÇjÛô–»êvg?73GäåË—9ŸëØVõ=ýÎ==·~4eý~wú´F¯ÆãqüäOþñéOÿtŒÇãÔç×¼ ë²&I÷¶VTýiÝžžžÆÁÁAö»ûÖvÖõZç”ûz_}_sQ´Á¨ä6‘åÕ¹Rû\Ûü¬Î½Ú¦Ùþ­¶½¨ëºÚÃùùùL°6'Ù¸ãããœßhI˜öþ>W5ÜžéÝÍßÑOµn¼ïÔy6???žêÓzU\jÇêÁYú=â>Zë]ÜCimk½jÖg¬Ë“““¬€4ûǘrgߣ®«jÓì•ÆÌÏü\ƒd]sÝü”QïkÝŸžžæ\¬‘æÚGž«׫}=0ó¯ÁõÙÏ~6™5ÌãSƒˆ‰$ƒX[[‹Á`‘™õ_l“p$™C …c™HklŠžï{ÂŒX|ò LFçw"âǯ®âw“ºÞµJ õ?¸½O_OÇï‚Þ|óÍd¡<«²³u3Á¦b=°/N'¾ò•¯Ä»ï¾›Õu°:Œ©ïÛÔ#"Y×ZѧnªB»ú¥&“­¯¯ÇÜÜý‰«ªmÔƒ†HC°OÊ«‘¤`GE/hÂþŠ©Ç”FLªÞ`‚h«G£Q²“֘鹹¹”Õ€Í*"¾®4£ßWYÆu{{;ºÝîTµmÃÆÚPÉê ^ssªƒ§]ÀyD¤“.÷ȼg¯ªôæàà ÷,Ÿ}(Mùj^2›×äbô)ú[I˜5܈µÔkØN¯–É®6à’Á&ÍñLálU0_ CS²0~6þ_^^Ž¿s|œl#]ï§[­øìû„ˆÈ¤!¬Ïl¸Zß0¢ô3F±··7771ó}´ÃÆÌàjoMî²™1È6NýmS¤å¬%Ôjäƒ3Åpc~Em'ÉÏ€} È9ÐZg¿@cÖ€EàAVîææ¾D›B›Ífnس%Kk¸øòò27(ÀØü8†Ãa²U•‘æŒè³š[7Å âkÛ`%IúyÍM SR‚ZiG;ææær~ëgΘ$s5ÝZzYcZsEDC®¯''YZæ±yëý8¢æJ­‚鼺ºÊJ€Ð]«,'öÄ<æÜ³ƒÁ þñ?þŸãþßÊ5,ÁX?Òä\@U•zU)K†’'­S§úÇœ–*ÓŠ˜œ£ Œg¯Vðj6›)Ù²>µ×qgÀ\«ÕŠ´§J~Œ§saa!úý~FÁD¥–——£Ýn§^ÿ‹4\/ª‰©Ïî¹u½F£$*Ìg똳jÞéV#ˆhkäcaa!qó™aóØ+Ò÷³?'s¹&Í«²¶ººš¹Íæ}õ¤ãããìO¶LÌiް5Q£*³¶Äz‘“uyy_2rcccªÍÖeunúý~ÚðçÏŸÇù/ÿ%I Ñf'y×˺®˜jD¬µäWšrl8` DLjU› ×××ÉLªXcLêIœ5²¡_…Ѭ*ãÀVŠ©Úrqq‘!ø*ýõ3§øuaºZÆnmm-ÁúÊÊJ†ëɹô ¯&%«Ä€`Ùj5œÑh”L_§Ó‰ÕÕÕt‚€hQ BJ8ÎÍÍ¥ÆÙg677s½ë_m5Ï9ôîg>ÔDØåååØÚÚÊ9óìÙ³èv»ñ©Oýûø™Ÿùtü…¿ðLIú*`‡±3§‡ï˜›’'½»ÏÖ(žûo¶ ›©òŒˆŽ9dª´2c0äz´>777SVÁ9ápFÜË̓AÚ˜Ñh”¿»ººŠ­­­|/sÇúSH@²k§ÓÉ÷׎ååå©WE.¬›~¿ŸÑ¤ ÐÊáöÙËËËxã7RÿçÿüŸ^¯—‘sÕºFdDDVpáœÕD|yÖ›ÄgÅ8+";ÀyÛ*µ´Ûí”þèDÈÍÍM%d}xžy[zïR×#'‹d˾dÕÐNvÍöñöö6×”H£{ ƒØÛÛ‹?üÃ?Ì}g÷àèr¤ÝÃÞa<Ù.{g_´‰!ê­ÝÌü«y=Èl^“ëW~åWÒpŸŸ'à’df3Æ*øÂØz6˜Ê :6¤ˆIˆŠˆÜ<€Ãta ?¯r†ÿ:ø{ggñíwwñ ï;ÆŸQ¯åkâ-€]«¤0þ‹‹‹™`„ ô*Ópmnn&@·!DL¤(Œn•^T´ ׯªµ‹«|Éfmù¼õ{ÕÖd«(ĉ8>>Ž~¿?Åør¡Ž }ûí·ãúú:O!Ä™a³M³19saa!z½^2°+++™à†iârll¤ûûûSï©%–ÕH kÕŸ‹‹‹¬¨Ru´µ* àYKrn)€ç'•7s™3Ójµò †ÑhÃá0% ¤€§õzxx˜ÎµˆÃË8ÚþïìeLÍ €‘Tm8f%Ç´–w%e8??n·›cÀq½¾¾Nt³ÙŒ?ûgÿ·øå_þ_âÛ¿ýÿÌwõ,c†Ùf[8¸ìƒû«·>²”%ãÆ©ÄîrÀ«T¯V)ÁÞQURµäÆ?õ§þT|ô£ÍÍ͌ڈtYÇ€ÿÑÑÑ”tpnn.2‘ªtÇüÇ™÷Â"#Kš×ÖÖòPUQ¬oï]“ÖÍýýýxóÍ7ãŸøD|ß÷}_:t¢i$F•YXXˆÃÃô›ï‹êØÛ7jÔ¹dÝ×ZöØœ±~Úíö|{Wv‡Ó¥:M•›ig±ÚmãZ+é/6æÝõäTvÎ|gÀ±¨‘b‘Lù«««±»»›Ì»ý Å™"}ª¡yW¶]´¼ÝnÇ_ù+å¿D<\¢¯wÞy'æÿè=\ßìÙEDäFÃ0Ê67ÀÒÏ•ûŠˆ<¬ÇæÅ0ÛðŪ͌ˆ¼?;(DD†òmܵ¬aÝ(?ÃÀ»€ZÀd´k„ n$µ2CD$8°ÓGGDÀŒ^2b¢9Æé?†_xÜÁâÕ›†‹çPL“C¶ô¡ïÔ£Ö«Œ s ,h×××ñèÑ£ŒJ\\\$C^“95ä,€†Í5"8ÞÞÞ&€!;âHšoœ.óö¸&‰Viˆ—úɳùªÏ ŒëÓˆHD‘£P?žb¨m„ñÁ~0ƒAlll$ãfN‘mnnFD¤þùñãÇq{{SÀ_s¶–ÙÓVœ÷;??ÍÍÍ|¯ÝÝÝtðc ´£šPSì´¾ÞÜÜŒËËËxùòe2¼œ|k¼2óús4¥¬ `ÃþØý݈¸?·Â¼±v€híÑF÷7—Z­VìïïOE„ªŒÁ㜎Ç㩜¶Þh4RÇ."$ÙP[ØK¹8o½õVü¥¿ô—¦¨ûýßÿý\³ ÷g1hS³ÙÌ}鮃Aæ TéÛœÕÓœ?sØÜõo_Í©°fD’Øí³³³LhÖÿ×××1 âéÓ§±··OŸ>Íùà3.ý#ÂSí ç…mì÷û©÷wò,IÙhbÄ$aט{Žwib‡Økvõää$z™}öœZ®Òúª9Hòwœ˜jNWýû×¾öµØÙÙIGÇ^xzzšûªùWÏðy{+C¿j?»´±±‘c?ó (ý]}í¥l[%oª_!‹‡ëÕ¼4ó¯Á¸°úûÊŒ`¶ê†á¢2j(`ÆDÔïØ„êÏ}¯²§µÔßìç«6âüÝ““øçý~üêêjüôû²ŒZLDÂ÷j¹·ÙûÎÞ»~ÏÏj”º«ZñÊëãYƉŽuö™$CÕ8—Ùq­l–¿::u gó f™>?s¿÷\÷­‘ l¬ßë ¬$ÎMí'ÛÇãûäÉ uv“Ѭl8ŸŒÅÆI‡O“mÅÀ Kª«²–Ê”`ä67734^AVºó¿~¿ÐhDó}Mü/¶ZñggñKïU¡òªý® -iа³¤§ñxœ¤DLÀ1ù&Pß-//ÇÉÉIDLØjRì±vŸœœ$[lñÌãããdÑè#É…ä!ôûýLb‹ˆØÜÜL‰Žïc˜Ÿ:¶sssÑï÷3$\…¯¯¯ãðð0ºÝîTùÒëëëèt:S Y$!•:>>NGÑ×Wàív;y昜I8€5’377—9 ôåÀ%‡Ïsž?žã´¸¸˜‰¤ÖÚp8ŒápOŸ>Í>TQÆža=Y¿˜ó“““¬è$ò„i¶®Ø%ód~~>ž={?μλ¹BNˆá·)݉ŷ¾H¿ŒeM f[e`Ì_Ñ‘X9"To½õVlooÇh4Š‹‹‹”ˆ²oWWWyPâééi–‹±2_«tOÄU%3ûc%Õô¡¹%¿ËçZ­VlnnæúÞÝÝM;<[Yëázu¯0ÿ\4Ì߈Å\ZZŠÑh”€Œb¸…)1P‘¼Ê&èìãY@´vxƬDÅÆ:ó^$56µªïÿ‰ëëøµn7Zð7øÌü|üäÕUüÒûìö±øÐ‡>ÿæßü›dÈõC£ÑÈd`öÜþG.¸¸¸˜Õlä%ED®‰ÛÛÛ\«5‚$É|v?°F×ÖÖâÛ¿ýÛcee%~ÿ÷?žÃYÉ¢–Æm<ôÏØ%•sªÑûÎÏϧf ‰Y½?FØÇl¹©¢Ÿä•ˆ o“:ï61m±AÍ‚+›¶3ìݬv»&,‹Êô@µ2—‘`""²/Ú$ Pk-7pÀyy9vvv¦7®ùùù8::šÚ¤æææâèèhÊ!$ý0Æõ}8‹ÚI6åªu©µ““ã„OQß㬬¬d„A¨{uu5=z”}?779ÔjV³}~~ U¯qÈ—ÄaºhN™šî€ §¸áÈú<¿&*ú,§]%Îx}cè-I{Ãá0#3æí£Gò¹5ñµ&Ž‡Ã´ ív;ÿ1©(RËBÖÓ@­kóÓº´†îî"_õ®~¿ŸN´Ã§ž?»»»É˜ÊÑà€/š}ÉÉãñ8óFfs¬ÕZÆ¡\ÖVµ²ÒUÓîoE/ýj¾Ö„R‘T‚ªH$Iæ}jÙ#¬#7™{Æ’óZKß•þ&³æÉZŒÕÚÚZ|⟈?ógþLt:xòäI¾ËÕÕU´Ûíh·Ûéøp¨hô%¹Ë—`‘"혛›‹n·›}ı«Ò¾ÛÛÛxòäÉ””=©{„µÂybïü¾öwÝ85Þ«qdA¢oöÆO~ò“ñýßÿýñæ›oƳgÏâ«_ýêT¹Mómqq1þÚ_ûkÿ Èááúf¹`_“Ë„ñü«L¤Êü±éaˆ~†›…ÄØPmT6>,#ø"ÚäÙ··“Ã`¨_h4büþ¦R+‚p(®®®â¸~? ;l`A±áF#¶¶¶¦JeÚÈê{ù.0Gç[ójŸk¿D)ØÏmþÞ‹‚„D¥ˆš( 4)I˜ð‡2E¦ IDATÍ% *â`L++,Oÿ×qDd9ÊÊÌW†Ëó8=••¯Ò.yG­ˆÔï÷ãàà ÃÝd*æÕh4ÊÍß8W`ÉÇ,K«ãgŽsêÆãq†«ooo3„M󺼼<•{Á1Òï Â’ù¹ñ5á@ꋚˆÈyóã„õ9ãƒõ«Ò0‘$ëªÕj%ä9”ÕIåÑ~‡Ã©DtΫ9:r|k£ñÅT@ØÖÊLHSeÝoooS¶RËŠ(q"É«VWWSŽS<Ÿ­Éö“ü‰™5qRŸ×õ[m©¹Ã©¯9lY­Ó_sFöööâƒü`Ž¥{°µŸª¬À6åT{^%"UcÏnh›wäij3æµyIn°)tèìuQí Plά¯¯ÇþþþT›>ΪiæÁ‹/RæãYÆÚ{š/u8??O°ï{l‹÷bϪüÎ8ùÛ:âКףÑ(²NúEûõóÃõj^Ìükp}ö³ŸÍå¬^Y}Z#‹h6›©ßĨڴoooÓ a° “j6ÀŽá´TYà‚‰ÞjU‘ÕÕÕèõzÉÂî ¬Ù 1"Ú[KÒED²ãî])¸²|sss©Yw@H­ÒBKÉ( }Kêm8½^/Ù Xp‚€J›¹UþCeqb XÔ—Ø=z|} è;±77D°K5á®:µâL»ÝNé<Øááaöw7®ïL^‚q¶ùcõŒ7 –_Y?›¸P=àS£XB²˜ÊšV' ;¨ÍÌ96—ó&—S«ÂÄæææ”Žß&\Á¯ù@Þ¡_€²F£‘ão¾+‡hN°œ!ÓXZšÔG7>ÀfºV¨Ñ•­¯kPþ½:G§2ìDã¹wwwSIËXWÏ÷}kû©_D&jek€30ßW$zôèQt»Ýsk}oo/e‡"õywïG ±¿Íf3^¼x‘òC 0"safKô;Ç“eq^ÔÚ'­ÖýÙ U^µ´´”޵¹ªJõh-}Û·}[&"׃øDéööö’ ·ÆguøjEkÊøŠê 4äeGÛf³™ÎÙÕÕU¼xñ"ž={–Uªèñ{v•̉Ñ|~í'~fþ±kl‡{ÉÍ©?W.‘¤š“vØ#윑Z!kmm-%}µü®¶Õ²›‘'ßr¼ÙUóôææ&^¼xð_øÂ²t°yDÚuyyóoþÍÿäðp}³\uæ_“ëŸý³–¬›0xMöte cÛˆ€Iµ}#"7Jˆ,„5g 3Àè ys†Pët:ß0YÖó«ÑĬK­Œ6=;PO,Ì[YDl¦Í»»²²’Rý¦.5Q+·h£ëJòä"wX[[‹ƒƒƒLÌ£Ÿp˜ûb‹1f³QÞl2¯~ºå`»¾Ð P˜3øc±O¥)=¿ÑhD¿ßÏwF¹¹K&¬mr~WiVÄôa/œ8%ìŒ`U#L’Ó*pZ[[›ÒÝGDž‚I—¾¿¿Ÿ@“Sqyy™I¿õÌÏ倶kkk±½½@ˆ­¤œåçjb¶ùS’m^]]/^$ˆ™ÀDê ïn}Ó^[»Æëk _\\L%Ès fÑÀ³ÓéLIÇ0Ê"Gú°>SÙONgöÔ(–uoÍs–0Úò~hª•Nd;äÏxouÛ9œNFµƒsss±¹¹™ŽŸ±m4i»*K|vv–‰“ì‡hŽþbG9øìÃÞÞÞT®¬&¬Öäz-ö»j±Eá”c$Y³ÔLNˆõÅ‘àT‘“t:Ü_êÚ4_UÚÉ~[õñ­Ï³³³,kã˜Ö*HÚõv\O8ÍÕ}j”ƒlËþe~jc•JY‡óóóå#«#1ª{ÊÜÜ\looÇââb¼xñ"ŽsÿUjVÄË|®9ì¨9ÌÆÙvww“D²%/‹îüõ¿þ×gáÁÃõ \ï¼óÎCiÊ×Შkè3b챈釪IH6ò;!ÂÙìø^Ž˜h,}OzV–RC‰•¥‰˜v0Ú>û\¿ÊfŸ ø`³e#&åÜ3‰r¶Íµoü©áçzUöÉý1Bõ¹Xêú;ZîúÝÙP·ßW¦‰ÆµŽUý×>¨¥$=O:Mpª#¦ÏjÍç>×öú3ÎUÕ†Ö~ó;É}uÎÔñ¬cP¥<•-sÕ¥ÞU•'ÌÖþ4÷ýë_K?Öryu-YG5){Ê™²Fj¢¹RxµIKõÿúκöÎÆ·–¬}WŸé:==ƒƒƒ©õËVø®¾õ,Éõ"÷0¾ì±ªe ë<ª—ÄgkÃå]ëú¡Á¨å9Ýß\¯eëx---%»ék¿ù¿Ê+úßÜtO‘"}¨­.}8Û¯úÚš¯kauuuª¼i-ZŸUçøÒÒRæ8óäææ&ç±ïøŒ9U#¶õ3ìK•T'©–¬m𽬅ÙòœŒºæ#&åDÙ?“7Q£vuïÑ®jKëçëz7Wô¡gDDîõùušÝ“ª}1VöÐñx<Õÿ¾oÖ½@ÿÕÆÁü¨ebgûæázu¯Íükpa,”³ÂZKºtâäõõý¡Aü©¥ö$ä Wc–«f«³²²’ì-=`Ä=‹R“a±|¤0˜ŒˆHF²&{U`§}ªŸTcì^$‘÷îõzSIQX —Ãlld˜!Œ”<ÖÔÆÝn·óD[’̲†Û݃á­Ò¡ªQÞǨ AW°…uÒ {¾xñ"úý~nDäPXÄÅÅÅ,+YeUŽ0??Ÿù=¹•ã\ÿ­Ï•¯«Ïët: ¾"&n5›Íxùòeê?7773bî‰òÐS µ×ˆÍââb<{ö,z½^²ä¢4L¼———yèSe™WWWã[¾å[âí·ßŽóóóxñâE¼óÎ;±µµ•Žv´Ýnnþöö6%?úž—Ñ^£ÂÍÍMæˆTŸžÞŸÛï÷sn]\\dÉQ2®·Þz+טhZ£Ñˆ/^d‘ ‘шûò­ ¹¯ŠÖÔs¼gul®Wózó¯ÁÅ DÄ”þ¶†«±FêlGD–«ÉO>Éù{? W­àQµµ‘¥Q›óââbêG–¥¥¥4VB°VÒ IÀ'msM”¬L.-)G;UY-šÖñxûûû±³³“§ÀVý,°*kræõõõÔ©»ÞÃU%'6¢šô¹Ñé?:pýB°+0+Ð'Þóââ"666„«ãˆòš,Öjµ¦¤?ƒÁ Þ~ûí¸»»K=éüü|ÄîînôûýX^^N`EfS“|9›Æ@[YYÉÍ›ÕÁÆÞxk4qttëëë BÓ¹¹ûZûÇÇÇ9.‹‹‹©)nµZñìÙ³þð‡ããÿx\]]ųgÏâÝwß½½½¸¹¹‰~¿çççYwss3ÁjÍ›Èl´···©MæìÈCQ½£V#‘Ü(—¢ßïgþK05ÁŽþÀŠˆ©²ˆ52·°°óZR/0}}}%>{½^¶³VÚ°Þ¯®®âèè(uÚ|LtM˜%1Så rWήþ•ÐIÑív§ÊžœœÄÆÆFJÑØ3²;ë«êö6kœlBýýñø^‹Ï†¨îU“9ëûu»Ýt<µ“WÏìÙ3’(N»kM‘ì [Zuí"äl>Fß:©Zr6ŽÌN¿ÔÈ Ù ù–¶Õ¤QN"‚ˆmc'µQ„€¨¥c»Ýnʃآ»»» ©›ŸŸ¿¯fÜ*C¯þý³gÏ2zƱÃp{gï`-פc¿¯‘Θ÷G>ΤJÎCÕÃÖŠæžÒ§œ5úU•\ªô ¸4‡0õ*|`Îà ?l„Å;vßZO©{5ÿÖÖÖ2ñPŸþUÿknj#&Òs¯®®ò®¥¥¥ŒŽ™K½^/×ùÝÝ]dãÖ»„`ÀªÊ8;jèW¶Ot°§KÀF£Q|⟈­­­888ˆëëëxùòe:dkkkSC•<\__gÍýÃÃÃX__Oà«JÍÂÂBôz½  ¤ü Lóœâ¯~õ«±½½=%-‰ˆ©ºíU£L§¯ªOĤŽy¬T&‡Ìò ˆµÇîr–——SÊ5 âøø8í—h'‘£ZuôÚéo`\s8¦}â8à"@/_¾Ì9fÔê+ôú•©UfŒY­4C“®L¯‹ò¹ˆ$éSÑRÒ¤BMĦ¯¯6Û¾Usj¬¥ííí¸¸¸ˆ“““Ì5Q©ëää$ÙzvÈ©¦Uójr:û-bµ¹¹™‘YãUs9DÜÏûU§ÎzäŒ9C±¡0ƒµ33²e¿¬q8¿€-@ñp½š×˜ .¿Å-®!WÌB³Ùœ*Q‰ ' ù}5õà à„±«2“ˆ Xõ9Ÿõ·óòò2š0M@WÕ;ª>P%îÏèÖ]FÑÏýÈi"mXU¢MÕá°Á3ÜÚ€mf¸µÁÏèBësm•MÁÑúªå­¯ê‰¾Õ±ñ^î)\‹)ªÇôë[ vqqq*1MÒh¡ÚhXºª5˜DlZ®ªÛ5æ6{à—³T7± À"&åáŒgub#&e+ãèÝëÜæ<<{ö,¥Ïž=ËÏ“»è C»8¤6U›ýh4Šn·›ý\;Q*õ×­ ëÄý½k=ð͘zOs@Eò6kGßDæ¸ûp0€§Y ªÏE_¬›ê$`ÏÎÎâ7ÞÈõ§ZÖÑÑQ‡ÁǦ3¨Œ*àÀÍX@Y˜_¨™!Åä´îXZÚqŸ¹ 1˜1i‹Ú&¸¼¼œŒ£ïˆžÜÝÝÅË—/sÌéÍ1Ƙ䚀Ön·§ô¼úl?5µr5þµµµŒD܃c‡¬Õ4´G™3Á¡F昺o=Ðǽ«4 p©¥$+(öžB¿ò•¯Ä{ï½—à“Y7\¬gFÈ4ÅÆÆFÎ/ëQâ%¹@eî"& uyy9CèÚ¸¼¼œŒ{•_øn°èkÇܦýÇû­V¢Õ•ø©_?ñôéÓ‡é ÐæGL´¼ûûûi'üœLj6›Sy"{5çbii)û¬:õ"2ôêž/Šf^™35 ï@„ˆ#]+Wq=ÉiàÖÖV,..ÆÞÞ^VzYXXˆ|àMä‘Ô¾ªÎÇlÛý8N±Áìõ¢4©ÈÛ±°°Q6Þœ«UŽ8x±½‚“Hj%zÕjµb}}=ɉz‚²(¬ ?777ÉD‹zÊÉ0ï9=îm=±ßör1m­1k‰_Œ¼’¢ Ñï÷s®Ð°›ïµìæÊÊJ>Côx8æ>@Î¥ÚÙÆÆFÎq¶Ê»WI¦9o_ô¼YY §Ü³Ù`ˆuÀ™¨¶ïôô4~ôGô…®o®ë¡4åkr}îsŸËoÄ„E¹¸¸H€KG,ŸœœLÕÇ­á_Ú¼ˆ‰„çðð0ö÷÷´aH"&e±W´¿6E ÐT7øV«5%-át0¢lV•J1¬6hFXbæûgã¤Mf$=‡žÕ3l €–„&Ì3†ÚF/ÑÎçR:ÞÊü)ïH^øatl¶Ú%?AÉ3m䀰ØSBaœ«”ª&GV¦Ðï§›§§§qvv–6 º»»› ³jüIˆh>766rc·áaÝÕ ®’˜¹¹¹Ô#ÛøjR]uÈÏ………L¸4_´¹jõÝ·ÕjÅóçÏó´]N—wöÈehNsÓÜVJ²ÎeóX{VVVâŋɢrêj™ÍˆÈ6b9Éz*PP>€"&gBp¼KD¤³ øb5k9OIÕ¡ˆ¸O¬¬'ÒJì­Õ<3çò,ò à–2ï+x¯¬¤õoXËÆ Jûúý~®/å ±æEŒ*Ç@«åa1ÈlÌææf>_{’p˜ÿF™@L«þ¿FÙ½š#£úκ18õú£FáîîîâùóçSåYJ„‰ñæ¬×¯+CΖ°õ¢C~GT£ ÖM•®!bÌY?eeÙ>ý('ÅsÍ_6ûêê*ö÷÷§"쯹â»Íf3óÂ8!Þa8fó·~ë·¦ƒ®>>[Ö™·+++)mëõz™³4?ŸT÷ {ŠþªÑO²Î8"G’ñà °¯æõæ_“ë_þË™›ÒìÆ€é¥9¼+óʈÒªŒ¾*óóói0ëÆBï‡e±Á2Â˜Û Š@ ¨ªZTàÛm㸺ºÊD9lŒj•aXi€Š÷l€–¬ÂóÔ"òÀrV€•j¸m6Q›gÕoz_'š‡Ã|vFxÖøù[eÊØ»ÿÑÑQ,--E¯×K]pM$# i4îëÁW°ÌÕ;æ-4ŒìÔ±©‰€†ÃzFö…9(iÏý‘Zñ¥êÞI½€RcÌÙìt:©×îõzéˆ`11þä Ãá0Ãñ4Ûuþè+Õ+ÌI!n÷ñî5’¥½ö©iÍ‘<<õÒ.L­ÏÔä.›‰Rf@vÕ­V­¦ÍÝï0‘̺‡|¥¶É†\ÛZß}~~R[Ú.t¬€$°àò H»~›)½6À/¬onn¦Êð‘ˆÐj϶ Z¯‹‹‹”pÙ¨#îÙsϯzU¡•@*›Yë£s°fkRû ÓYçOu ª$ˆ.ܸׄlßÕFò°:ï0x@½HV]OÚXóAÜÇçT01fÊŒú¬¾¬µ£#¦uÉž[ûÇÿÍŸ1ÏkJ§Ó‰Ù«Ö{¯kÁ<á¸?ÕIq‹ì™wµ?kE{é»=¿Î[ŽG ¸óûª÷¯W%(èŒkÿ™cS•wÑ#K*%ñàhW‰Ÿ1Ó}B³ï0¡* ÑÀ«ŽÃÞÞ^:ÄœWÉÎæì{X?ädËËËéHÔJas@`¿ÚcÕP”l­óp¬s»:Suú¤F|âZUÈ´–8±Æøêê*£¸"2UZÅ!;>>NGÆ<ª{—*ïBVŽˆß›Ÿµb”{H®­¶Ò»³-~(SžS³´´ûØÇâñãÇyØ›¹vvv–v£FÈÁêû¸ØJŽc—‡ëÕ»F÷5¸“É ñÄbîïï§^»‡ù¥¿Œˆ ª5nSb$èÞɪT†öQˆu¶æ:c'ŒqÏb¹G ã2n6.›šgq@l²ê5«Uì€ð£££4r6J5§4Ñ6wÏ[__ÏÚòX“£££dÎj8x¬†UßÑjú?G‹c1ŒˆÜ¨é¾I4°6PºXIÏX2RI]Æ©ÙlNi^ÛF£‘úwɘ£Ñ(¿ \«g_û¨ÝnG«ÕJÝ+A?ŽE6HdH-ô£þ¬°ÄœÑÞââb–5½½½¯p´µµ•c{vv‹‹‹Ymæìì,¥ 5©µV@Gò:~Åíímê©}ž>¸²³ææ,brÇamm-öööRãL7LžåÙr!ê:«U>êa_ž§Ÿ¹épã" Â¨Ò ±ÙlNõÆ="’eWz•†~qq1666²L¥èÄíímæ¢h³¹T™Ûºfç†Ã*ð›'+++ ~´Í½½Ÿûº77÷µÍ«ÎÝi¾www)‹õ:==v»N'FNE`ªÃi¼®®®RÚ#ŠA/þèÑ£ìÃ^¯—'šÖjOæJbæéHÀÅÅEÖÌ7¾µ?—––ò„cßçhUdM­sÀæ°­¯¯§Ô¦BøÚ×¾o¼ñÆT­­­œûÆçêê¾æ»=Éø«€eßJ÷j‹ý¢îI" ÆÓøcÞòåF£‘'üZ?KKK±¾¾žöG›• e‹ìgd1ÆH¿²ýèGãû¾ïû2ùùÏ>¾úÕ¯NNµß½IG¶:O`Žl%,®WïzÙ¼×oþæo憄¥VAÛäg«˜í¥¥¥d$_Õp!‡³áWvž¡e$kåÑz/Ǽcq€aFí&¶¹*åxvv'''ÑétòkÒcÕÛ6›Íd#bJÛ1}ÀCîg$œ‘Ys•5Ø0~ g~`œÝƒŒ%"P+ïÈH÷z½Ü¸mf68áå‹‹‹ü}M8¥«ÆºŸŸŸçáN‹‹‹ €TLj"-€ƒÇhÈͬl}'ã7??Ÿ9Éã*™ÁÞÑ+ŸœœÄh4ÊðuÍkÀ’êN€Hz¡.~Mjô= Ç<®9$¤À`4??ŸµÍïîîržYdîè¤lnnfr]ÕÄW¹f¾æTI†’üÀüªNòññq:Öœìšl-rp)a[µºÕ^ ÌOyJò‘³É#!9c¬36˘[§¢‚UÖÖjµR"Æ®ÔH€wQu„Ó{pp’ ó¬œäy"aï½÷^2Ó³Ì. lísûý~:„l„¼‹š÷rrr’ÕüÂþF£<ˆ¯Vbñþ‘¤r¡ˆmü""×™ÜcÛl6c0ä¨20:qïgþcˆÍ- ž¼Šƒ×étRçÍ™![Ãô7$ƒùIRxss“†u á|4Åh4J›(ˆ£$òYmQD¤Dçìì,öööÒ®c齃µ:77—à›o®’¸Ðì×qŠ˜T‡‡‡9¯"":NÎÑ/ùËñÅ/~1^¼x‘°š÷A)šiì×Ö֦檃ã8È———ñÃ?üÃÿÍøááú“½óÎ;Ñø£?öp}³_µ&.F•«¡õˆI(•Œ˜l•™¨‰dõ° ˆ 3ƒuÇ(cÕÀ¹Ÿv2^.lŸÏUö“CRAruX$ïbýý¼‚JïùÙˆéñ¢M¶Õ………d»kB­*4|y¯êÔ¾¯ 86µ_ÕI~.ï` 5ÿæT̆æ«\èÆœ×ðºÍÓ,jaƒÇŠÖ9¦ £Ñ(ˆ«««ÜœF£Q ƒ”,T笖#Åfšæ˜>Ðh‰ˆLô•d«8sU¢âˆõ:Ïü¾:rU19hXUYÀr_àÄX`êÝǽ½o}×:εÍõ*Ï©:} keii)«†NH¶[YYI?öÖx»¬  œ}`ª|Áõ{¿¶.WmEup"&ÕI0ºÖr-Y%f¤uÌ©ª2/sFtpVîâ¹ú¬ßÛmè IDATF‚TúY]]µµµ)i çÅüð³…¼¿ù `²IœN'[K·¹m=ÔµnÍyÿ ÕÇóóóéØëKNLD¤£…TåNì$P5Š˜€pŒ¶gÎFV9LúÝœgŸª=3¦¢5P#O@®ˆ\MäfoŒK•DÖýÀZé÷ûéô+}Y‰)W•ØU9eèÔ=ŽÌF"¬q¯Q±wß}7¾ð…/ÄÓ§OãÅ‹ù¾•ɯóR^‚=Æ|®6Œ}¸^ÝëAfó\•-¿½½ÍÍÍdjUàùWÐÒét¦˜ÚˆÉaQŒ'æL²P³ÙLF²&^V$´Í ¨e!±s6ƒ*!‡ÀNÔÍ‚Vr8&«g—ðÀÓ_V©FM¨Œ˜”¦¼Key%ýy_Iyͪ•XeÌïååeÊT0ªB¬´TfðåË—™\êTн½½XZZŠ~¿Ÿ'†r¤0¡Æ @Ž˜$÷ŽJÙ‘ Ð/jÃëW¥k’/­üââb¼ùæ›éTGQ›H§É"&§ÃŽÇ÷§ð’ßH $]Qí"b¢®Ìo—ä*’ +ø"‘¸tƒ™#§0rL8˜u×××sž“È`²qíàW'Ëú0IÜ\¤)"#œAà]d¡2Þ‘eµ{uu5Ž3úQO‹œ+Ó[åAõtIï¥Á™Y__OÉZ­b"UµÜÖuuÖ¤ëëëØÜÜŒˆ˜Šà. ªÈÄ©³Îëü3ŽÆâòò2NNN²œ¥hŒ±à¼ODÄææf&{²“æ–õÝëõb~~>öööò+ÏT•DNùÁ1´$n³µàyŸud®Z¿"Yl|³ÙL›J‚Ç黾¾Î5¥4hod…±c“͋ꬭ›ÙN ÇŸýç,DDAà´Ø/NOO£Ûí¦$üÌ~FkoŸpX_ÄÄÒî*ƒÔ·5÷Dßr jdÆ&ýq*´ƒÈ*±U¥„䔆Ÿ?žÚÙÙY¼xñbм¨k‰mõ$—#Ó”VÏCûp½º×˜ . S8߯^0 0£ .éµ<àˆnÑçO›--½=C‹I¨ÆµVÁÀhŒU#;{¬µkmm-5¸îË`zÚHFS’/G£&§Õ:Æ>‡ý÷ÄHÙÌ›ÍfaN,vïúúþ´ËZâñøø8Fê!iMÇãûÊ J’$ý†)bÔ···SÏYß3Y¿'‰¹ö³~hµZSr#  ÀS½؈Iõ³œ„ˆˆÁ`›››éT´Ûíd¯92ý~*Ùx 9fÏ­,°ñ!·ñ,Î!‡Ã†Œ÷, oDäÁVäKÔŒ³1$¹Ò¾ˆIÄIH³ª³H÷+GBßš¢pc]Ðf=bY~m¬¬§M¾F¾8#XwÀÙ)¸+++Sk­®ÿ¯N©ÊOòHÿºžjädaa!#6æ Êi"ý2>Þ_>‡wd×8úÇ鏿½È£¹(ɬ–ìd÷¬€ªæVˆ€T†ýàà VWW³ê ‰„ˆHékíZ[[›’siƒ>N———Ó¾T9•Äoó¿Fœ8qö†Ù$f,4›cZ«Õy®!L”˜Àõ¹ùîó5i»:rF#‰ óvgggªÒRM˜ïOÚ~üøqoÒx|ŸØ|ppì¾þ­QNºŠ05ñ•c#ÂX#Ë¢Œœ?ÅôõgoXXXˆ/}éKY5«&û’+É©¸¸¸ÈŠWõ\dZ•Õhg%®WïzÐÌ¿×ç>÷¹©Ä+Àµ GD& 1V€*­#–º†û€kA3Zå7F#¶¶¶Ržõb”0N4ëØšMxžŽãúú:666’ ÆÖ2dõNŸaÓ‘øFÕp*›tˆT(sç=køúú:¶¶¶bss3þåǰAãñ8k¿‹zÌj‰#"ß½V€±qùþT9ˆÎXû+{ÀaÚ°ò€®úÒìêxk÷ééiìïïG£qŸ0f~óæ“ °¸«««dÁiŠÉ¶$ 'rs{{¯ç÷Ç<­À„¶©ªÐâ9“WÎg- ç°-ì›±\jÂöÆÆF:c6ds[<[uDÿÐõKº¬%.{½^§ û LùlÕ%s:Ì•^¯—cq行ఠê^ת1tÅÚ-"Òét2瘹»»?¨©j¯«­ž8©®'Z¶­ÖýY˜õYÇ»ÌvÇãŒøx÷!Ǿ£µUÏ-à€Š‰þL§§§Ñëõò ?³Æ1·µÔ,‚Ã|Ü­¯úÛÛÛt¤µµ&βÞÓº  >9!ì{·ÛÍÒÖ××Ó  VEY­]vÄýƒA4›Í¬µþít:©ñgwI­Y$„ûTI•>>;;ËöÖ5ÈP@gÏŠ¸Ì'''1 ¦k'¸VÀ]A6’ˆ£Òl6³Z»e_S»Þž¬c‚Õ·VÍ¡ˆ{òI[ÙSˆ¾~Æ3fKzîååe%{Xÿê…1qÿÙwÖþDøÍûTÖ¸nÐõÞµÝõ}gßp¯›oÄ= ã`ÔûÍö¯qâŸ}o2-Ï™ý}•!­¯¯'ëäÙ¤ õ½þkïË«å;ë7õ½kcPeYî[åUæo½—{cÝ+SîOĤ …ïÌŽSí‡ñxœcîk,*[íOãæví'l«þõÿºÆª³V>ò¿«ãŠ=ëÅi³^ݳöqÓY[ ÿ¿QÖ2ˆuný׿½«–&õžæ‡½‚vý>[zvvn×±76³k½–Utß±«ÿ®¶ÆU×µûk‹þ¬å/õ-{Uç¦*.µü®æÀïšsPû™ÆÜ¬IåÖ˜ÜÎ|¿:^æn*Ô$acU%ˆÕöÎÚÕzÕßÕµ6û|Ÿ­s‚ƒ2k‡g#ÍúÏX×yçÆô¿¶ÇšƒØþzOÏ™]/Ú]£³íâ8ÔßyNï®Ù=þázµ®‡Ñ}M.!ʈ‰Dƒq©§ÑaÝ""CãBçBϘ¬o ë3ô˜¡gŒýââbÄââ}Ù@l"CVµâ'''Y “icŠ˜”öÂÒmW&t^Ãß*ÞÌ‚`‰^5ñLuˆ*'ÐO´‰õ”P!lÏ•”Åà Ý c""# >ƒÝk·ÛSì#™ @"AÐI£ûûû¹aXOŒ J?Ø)º\‘’êDxc88™×˜™Æ„ÆZ˜×ÆïÒ6ϳ9“ííí%“«úNMn<>>Žv»›šðsÄ$Ò ¼o“ÛØØÈö]__Çöövæßš0'Ñ’DFˆÝ8Ûh2ÊSå%6c¬"6´&&êóÏ…¥öœ~¿Ÿl0zgggJε6‡ƒAnöžgnzy]žÖד'Or}´Z­Lás^i€çççcww7“ô€Ïê€D Ù@pŽˆxòäIÊ6šÍæTBÖh[]‹"òf°Åóóó)-3&Xxï# ÚÅá3‡¼Ou6WWWãðð0mîÅÅä 0k¸¤Qg...Rr¦”l¤åït:9¿ª©Òý¦ÖSöß3܃ŒƒÜÌÚÕÕ’¡Zy%²Úï÷“9WqªÛífb¸ˆg-§ÊÁÇ™‹ä®s,ŒËíím ‡ÃWaû›ÜšZ*¶²÷ÖÛÔn·³°‚=so®°£æ½u*2ç»$Oúóüüsssq||œJeË#"KFŠê8£€½‹˜èÓ_¼x‘ÒR¿^¯—‰¯HÀк'‰s`›3-ȵj©®qò#÷¥—¼Ž¼ðo@ùêê¾L¬2µ1å,Ò{«ÕÏ6{6 žõÔjµRjX“¸DD>G{1 rÂ××× ¶­йa~± æ°¼ ¶’Ô«æSœœ¤#Á†ÖíÖ¨|ûM¯×K‚}ˆ)Ò¬žë@ögâ´÷z½|ž¼ûž“mÉ/ÏÏÏãìì,m™qª6°FÏ®W÷zó¯ÁŒWÆÖ0"rc"ëa"uÓgômhØ`…á¥ß‹ˆ@º ´êâ[ÏÈÚ–(Á©J mÞqĪn\(ÄÎÖ4–3Yé‚–•Ž<"r3,"îF›(6MU•št5[½h>==“““Üœ9J>ã6ušq›oedü\ŽŽò4P M”!"¢ßïg_FLª‡ Û¸¶Z­ìSΪÕ&‰ÂÆccc#ÎÎÎRWÍ‘«õ¼E"jºˆø:Éj5Þ¥JRZ­Vï l˜[ ]ߊ‚HòshÌÆÆF\__gíðÛÛÛdÞ8aÃt<µQMmN!6[d¬&fw»Ý888HÇÐSkÛçÌV«•u·Í‹š8,×£JÜ`æ¸ÜÜÜ$skÞY«÷àhy“Ð XøÙêêjt»Ýxùòe&§v»Ýd1”«¬b*«}r@*ÃÍÙâhÓºc«„†cZ%Gœ ,²(’ßF£t6""« YsìÕÂÂB¼ùæ›Eb‹TÞ Yæ‘óƒU7O<AÀ)™ŸŸáp˜mˆ­eÑT‹ôfwkk+#&¨H–2þo1ÞUŠãgëuoo/£Ú6[Á§ßï§{tt”QD Õ<ãÈÃ$Ýjµ’gÛªý{ùòeºU“…ýžŒÝ·æonn¢Ûí¦­òžÝnwJrjÿó\¶¤JùD¿Ÿ={+++Yœ€ýãØ#9‹‹÷ç}´Ûíxë­·â‡~è‡âË_þrüöoÿv¤­ÕmØ)ξµ6®Wózó¯Áôßt 1GD²´ÀpËh7›Ídž÷ÂzL€ãÆàFÜf`Ø÷0ÊØW°d 9 ØV j@pe‰*ƒˆó;²ï¾¼¼üÿµwæq’VÕÝÿUUïÓ=Ý]ÕËÐ ÛŠq ¢((¢`4®ˆÆ|P1¨ñU1¸ÄH¢IôÕ¼QqaFÑHÜH"Q#¸€Œàœî齫§§—ªºï=ßÛ§zš™§f¦gºfÎïóáCO÷SO=Ϲ÷ž{–ß97UÒ\ b±[MÎßXÆÇÇË"C|Ž;d.ÍÈß1Hɶ··k`` ¬ëép‹é鹓Qm¿w2.<‘7Zhb¨aðƒÆÆFår¹ø®È C ã‡M : Ô"í¶ÐŒïÇ!"n YmäšQ5œ<Ë©µÝJÈ”ÝàÒÕ6Ë‚ñÂÎ!d˜óD&¡UØ(:…õõõј'‰ÁÈ|€zÀmeÃ3c4C¡ÈŽï£ðœ"7[ ’q~ÊÚ­Bc£Ç¡GÞ¤ó¹'ïÉç,gÚƒ“ÖÇàå:ËA·4œ 澊åï–WŒ+)Ž zˆˆ-ˆ8DŒïäY-MÌf0îÉØ@k“L™;IeE‡Ì'ææQCCƒV¯^­\.§¡¡!Ýÿýñ=Pà Û¶º¬ÞC†ÎFVN´D·c˜3nét:R[]Îø²îŽ:꨸^­CÏAǰFm;Ô4Œ`l Ö…¥ÝAó)‹qÑ VèFö 2<“]ÃüŽÂQôÿ·ú™L3D¾G…`÷¥‘rÃ9·AÛú·TšíÂc;´YùC“!ø0>>ÂeË–iÅŠêîîŽú V›õæmozÇá ïfsà3ŸùL4íF…"fC ÷<ÍÍÍÑx#ÝØØ¨žžžØ½úÓÈÈHäŽâ„b02¾¤’Éš@¥Y¾|yùä8þ!-_¾<1–®†žAf¶+t ÈL&°–––èœÁϧ.®Q¸×¶=¬q°ˆXc`C×Àa¢}$Ï‹Š£h5H4Ù`ˆá`¨·¶¶ê¬³ÎÒé§Ÿ®b±¨uëÖ•Õ¿ —þþþXGBPGG‡jjjâÚÁy²ºÛRíl: ã,Í:###Qç€Â5>>9þgœq†Ž9æ˜-/‹ñÄg4ÍÍÍeí}™ 8&Ô¡›q4 AÊd21hBtùÍžÀüÇéc²q„XW¬›®®®è4“áe=Xú4ÖÝ¢ØÓlÆÏÒ6éàS("½Š=ª*ºËÎqî…ƒvÔQGÅþô¶pDéË?99©GyD>úh™ƒBj&ÙMKÇI§ÓºâŠ+Z ŽjÂ}÷Ýç‘ù#P\0IábìZ ECú›b:6؉‰‰i¶Ñ[pc#O“““Êf³1’` M¡•XÚ¯4kÔpÄ8F³åƒbÜò½¤o­Á‰aB[5Ie\HøÔPˆìÀE&p¡1ÆØh0:ˆŒa8a02˜˜ˆrÁyæh2D¢lT”÷Æ€ãxsRô êéé‰xž¶h—ïÁ‚ƒ ·xpp0nÊD”ã;YŠ4iކc ·àÆ·QEÆ®³³3nŠlÊk¥RImmmjhh(ëU%…9 µ9.)ö·¿·ï†‘gÓêvL-?Vš£‹1Ž–;::ç7mîͦm#àdˆšÂùdzZétZ7nŒky‹ñ EÀyçùV¬X£Ñ8³èƺP(¨§§':û¶Hú5™¶ééi­_¿^ƒƒƒÚ°aCY†ŽìA©TR6›µ>è_žˆ:kŘ!&ûËåâœg~€ÈçóeàQoC`czzZ}}}ª¯¯ë9”Éd¢ž¤·<úˆ=ûG6›ó``` Ê} ]R,´Å´mˆ‘ßÇX±6 …B¤ÅûZǃöØWЧ¬?tÎ/N׫¶¶6êiξ¾> ©µµ5c0Þ­óÄÞ@Q=: ýÏÞÌž‡,ššš´aÃmÛ¶M7nŒíšÑçÌgZdâÜq¨YWÎÞpcþ€MmÛHç|Ù´=ÜmŠŽh÷´ÿ¡Ø‰ø©ÀBéÏÿþ'*Ò!e‹ÇÏ8#ÚD&ènaßYš; …gÆ C.D*‰¦¥àýQ¦(Ð…@„Èrò‘J–ÿ,•ÇÊâ€á XÙÙvŽ<#Îïlÿγ1^!6ˆñŒÑÙÔÔ¤M›6Išk!ʘc0À#Åè€ö@ZšžgÓv×@>P-ìñèy<÷|Y# (´°DŽ\ÃxØô=ó ¹3Þv>#3¨¼3¿£e†ψL)èå}p²ù.;xnœ"À# /ž‘,Å~öx®Ã‰°2$2L†ƒ{3w0ìqm1k“ùÌØÒÇÎ?¢›– å *˜í&„Ãýùîžž{ì±ñ 6æÀøøxœ÷D¨‰–óÝdeæËÞÎIôúLš;¨Ž1´÷Av“““Ú´i“£ƒÈ»Ø"KœA>#):Û’Êæ2†¼]ÌQ[Ð+Í5AàwdçxîÁ‹Emß¾]õõõ1:MD§tþ3Úú$æï?==]V|˘òoäm»‘!'æÝÔÔ”ººº"?9á»™W¬ct5Y¢ÿÈÝ•lƒ9 ÍŠ¿¡c¬ÜyN~gu4:ŒùÆ¿ X [hþX£ŸÚ6À3‘µd´45[¸í8<áÆü 5›2$õOÔš™´:–DÿˆHÔÔÔhÓ¦MÑØ˜˜ˆ- mAiccclSID*ÀäädŒ‰°Ú`ˆwwwGÅHÅGôqrr²Œš‘NÏž¦J±d!¦j‰¼°Áµ´´hûöí’æN¤åûæsx¡Z GZ\{h3¶öÀæJsi0"}P¹ýÞˆŸWWWW\oÿ8½è[PE„ùÆ:'S”N϶ׄƂqEÔš¨.Æ"™«SN9E§vZüã íÉfqd$ÅÓX‹Åbl™KÝ ãÏsÚS;¡`Øv—è+•…_ߨØX¦›˜Ï8ÁÌ+œBœ<Ö,<ù©©©©¶ó€lTB AtëŒ #j_SS£¾¾¾²5L¡-}¤Yçb`` î'è{"ïèöºº:µ··ÇÈ2Ÿ§ K:V{{{”F.†4ô16 )ød?9ôŒ}Âv¡û{Ÿµ§ÍBñ±µ<|Žö·<çsqG'ñ½<³­1koo¾±m;Ræ5ßÃ~F÷æYiî°/œY{¢5û®ãð…óGˆpaÜÂm•渆P$ÅÍ % _‘·t:¹ð±ÒÜlð˜áâò,(ZŒX~FibŒð˜Pf,¥…ÈüO¾·½½=F°ì{A)À¸ÓòåËc„ÅÒKø™è ZJ`Ycˆ“TüÌÌLlßH\škIKŠ›F7F¬åTsŠËà´‡Ê*úÌ)´=߉šñï\.©Fl0D‘é} 0686³ÚÚZe³Ù².F8<–úe»;àà@Åaã…cËñ%êÊ;ó\Ö¸d~“%Àȱ=Ê1Ä(@¶m:‰öax ³½ž1ZpjÙ¼q ™ïüLä CÞf¦¦¦´eË–¸p¾™{²8D6Âh£®---Ú¶m[œ{Œ)I±&±%¶g6Ž sµŸËå"Ï[š5ìÆÆÆÊN·, êïïW&“ÑÊ•+566玲bLOkÌŒŒŒ”oC'«««ÓñÇ_FçÙºuk|n"þDÐ;::b­Îôô´òù¼º»»#õŠw†ªb#Ý¢¬ èBÌÚrZZÕ ¼+Ž7Æ–¥@!Gæ#γ5¾·oß[[Z£ŽÂihZ©TJýýý1SD ™Ú"r2 <Æë]Šc˽kŒcê˜ÏP¤¹z tsžòãããe‘i[ßš$¨`;úØFèwô2:Áfƒ†‡‡#‹ÎddëàíïØ±Cƒƒƒñdi®Þ c›9Èz#»F+_ô@A¹\NƒƒƒeûóÆŽ º½Œ,,{ Í#l§/‚,Ô"X°Öm”ßqxÂG÷QxÐ’b‘šMcì°q°‘ÙŠx ±‘‘‘Øó#SR™Q!4?JK 8¢O(”Q(ž©±±1¶€#ò…Qbm¢'l…B!VüBa‹Åx@FQeŒkÒù(QŒB:õÁƒ[#ÍE$EN/›åÃXE^¶°Rš;ÀÈFË1šé5Q/ŒhŠ ­±Æ&NA‘o8¦nfÆï³tÞAšëzb£¥555ѰÃH«©©‰óËét:v cÂü!D^³$­X±"~­Ù@iÿ‡Œ¹/kNFÈ*ÌÀÀ@ä=3ŸÉ¬0ÿqÔpH˜Ã¼c‹#ayØÌYÖ/sÊd­0æ‰:"c²qƒi8ãétZ+W®Œëù•Q (0Ä@bž“E³­`YsœèI Ào~óÕÔÔ¨··7fpDp^yg{PÙZc’9hhhˆ†4ïϘ2wp¦w®±†óÔÔT\¿DÞÉ–B¹"“ÓÚÚuKCCƒÆÆÆ¢öÏ[»ßIDAT‰¡ÌYýýý»ËÐPx62@Ц˜;¯¶CÐÄÄD™ci)2üŒ,Ð#Ðyx èœÑÑÑX`MW–;wÆÖ§Ps´­­-fSÈ^JЇ³ñ]|íNûãH“Ùà½ÚÛÛc7<}è’èoPà~¶v…yIÍŒ-4&€À|hjjRoooœ3ìý3· …Bì³/)¶žEwP7Àþ¹bÅ =ðÀñEtØܘ?¼á£{€è»4wÀ ÆІÂJi®ƒ›è ´¼"BIçÅR‘æúWu“æZ¿ñlÜ“ûØ–vDµ,÷Ÿ¿ÙÍßrÙø1`æ×ØÖ‘|Ÿ-äP+z4ÛçæûÉ*XÞ8ÏE/l`¾¿P˜kG‡Cv¢¦¦&:llZ[¼§­mÀ ™ÿn–_Í{Ò‰>,GƶpŽ 5V1*q¬ìFG€ï·YºEÐ}drr²Ìàb²‘eÞcŸ(‘¾ááae³Ù²è©¥X°éãÜñ\¼§›<F.ーج¡ 1.!„H‚2bºþàta@qá{p|Y¬)ëc\1nп0Ê‘/Q<Þ‘÷…>EQµmYiçuvÉ8ÍÆ#044‹±Éf2µµµEž0Fª¤øî–¢åˆè3s‰5GD§¥T*Eã #œ6‡Dÿç=z ĶRíììŒk„9ËÚ%"Ë:D–DljŠÛà N ãÄø±Î‰–KsŽ®­!ð€Ch-t ëà ² p͇×Â8g¶# ÷á9¥òºŒfÖzÍœ‰ÙVö%Œ}œÀùÿÈ”yl×;"Ö·4@!cl jK‘C‡ŒkÅŠq="cûöJö9ôiô.{ º5“ÉÄNZJKs‘}®…×oO&çïŒ56Ü}ÛÜܬ¶¶¶˜ àù#îËüp¾ðÖ”G>ûÙÏÆÔ'Fˆ¥EºDQ³Yb\°1‘—#Ë(pÛ¹­Äø MiÛˆ ÑKç°?ÊÈʶª±ÎOÑéÄ (æNò$Z†R´Çƒã ÑñÄn.Òï'‡wµiyxÅl®}}}‘&·”hÍB)s6œ±EÆÐ)0á¿áÇaaƒ†ö!):7Dªq0nˆ°± Mç9ÆZAÙl6F[¡Îà4Bë€Úƒ±cy¯\ŸJ¥âa\ÈÖÎ?è`8#tÐ<Ø·nݪ–––؇„ïÆÈ†ªED>7­ål–ˆqÃÑÁ ã9ía=Œ%›2Ÿ‡‚`))Ì}"¤Ì xè \­ÆLb¼Ã¶ÏM׿XCCCìj„œˆ2†´wdî566Æö‰6ƒDo퉉 år¹²nEccceœu[¨<<<¬|>¯ÉÉÉø|ŒÑLæ)ºçÊžaQÉÜfíÚ:œ7Æ|rrR£££Qî¶›ݰh+ˆƒ‹.EdîxF2Š|ŽCÁ¤9#š{['AR”?ïa1q²~è K"[ŠþC~è,>ƒá‰ñ-©¬í)²` K²]]]ñßd+,G:–-g®£+Ñ!<: g¹œ‚ªÃ5Œƒ vàHâÀ3Ïl·+ž£ÙFíÑÔ® CéÔ„Nä12bÔÔÔÌž„ÍØ¢;\ÑÁª±±Q«V­ÒòåËc÷2IÖyd(‹zÕ«^õĆ‚£jqß}÷¹1$à‹_übY/]6q”³¤²MÁL’†&ÃÆŽÑ‘OÚÞɲ™`°c0ZŸ(E¢l²D㥹H†ÝTèuŒ¢å;jjj411 Ò™ü›ÍÃ÷DíêêêÔÜÜ{÷Býàz 4"6ªÏÆ;¿øÔò‚‰\=þøãjllÔòåË£3Ä)¡È*¾ñññض^.Ô6{(lù|>Ž# œp;öÈRˆ1ÃF„ñ‹¾|ùòh 0†ƒƒƒqÃÄ) X ê Ñ7 Gygë ðnÙlVíííÑ)ÅA™ c烣 Ùà<1×p læ†ù†q’ÉdÊdFD'†Hbkkkì7m3ˆF´šH1Ñn6`¢ê8\Ð ÑAæ=s¨#uµµµPKKK4”xÖúúúø|œ6Ëz©©™å§ãpÐVÕ‡Z£žq$¢m óp ˆæãt07˜|‡¤²î1œ#€lˆ4S°œÍfãœ$"Ë»,[¶,:Éù|>€¬-îo©€555Z³f–-[¦áááhÙˆ2k ª†[SSS¼7-‰ ÛÀúÁRÉ07Ñm!uuu餓NRÔÃÌô’­uH¥RñdYiÖïêêŠN´7 RÖò$²N„¥Õär¹(S«G¹'uXµµµ±NbllLQ'Ha­hW]]zzztá…êì³ÏV:Ž…§Ì8—PXÐòÌK»/mgbü(Î' @fŠùãƒÞµçÀq§ •ý•Àëyà¨ó]4 zŸÉdâ98)È7NÇ`Åôô´úûû#?„O;fàdð¯|å+÷Å„p,qÄ>ó¶ºßqøÁ&ÅâÜ¡8DHû±àm/m”I6 xœH¤oI+m) ± ËF–FFFb*Óé@}Á9 *Äç‰D²qAa°ÅÀlvlš63d‹鹎ã400 ãŽ;®ŒBD/i[,Fô#ËÒ†p ‰ á8ÙÓw‹ÅbäðÂÃÅȃ†EŽÖÖÖØjŽÚcñññØ»ž¹“Ïç•ÍfÕÔÔ¤|>Ç“ÌF?‘jÆ"—ËÅZ¦¦&µµµÅÃÀ˜¬1Ö6cOdœÂSøÛ~Іh¹‡œp€FFFâº#JL]Æ|=…œ ÔàìqæÁä䤺ººâÚeÍã¬ñDoÉ1O Íͧ²àè÷õõ©³³3®G iIQX‡#ÇÞÒnpš,µŽˆ:³\t‚-d˜_333Êf³*•JÚ¶m[ ’€`.³6 HRooo 0¬X±"ñ< zÐfN‡††â>ƒXWW ^Æ‚Ìå¼ã˜¢§9À ël>Uëù.æŠÕ‡|†6«Ìw2eü ˆ­ bŸÉdfÏ2`^ /í»`dåf EÞ9Nw™B¡ \.,tMãyÁ)öôŽíþ-HR4úy7ô:2% dÇÂ:Y6ûì8üJ¥œ3¤ƒ…BÉc³³m÷,P(¶Ê^RäÉÚ>ÐpZù~›¶¶ÿ—æ IÁc`ðÁ%µ–ÏC ¢·Ðkøn"Í…Â\gäÀïØ¬-§uþóc,`Äò½–;‹ÂEÞõõõñÀ“Riöà#ÒáŒÊ€MCÅrÚéÚxO6sÒú ]cSÆlðöw8ntLaãâžÌ;GìxÖ×Ïõ§F¶vþÁÍ.•Jêè舛9óP*?èŠï%’ÇwbČž-ü²°|Xî˱±cè`„q¤²éÖ?‰¶"û…¸ª|ÆÖQ ?Œ/Ö%÷áù™¿’ÊÒÿÐ?ì|áß¶_<ÆóÖRÒlT¾X,ÆBCÖ7²¥×µít¯×Ž3Ñl;ψªÚg´÷ž_KA1"ïÏ;0D¡‘Ñôôthi€¹mƒwÅpg,$iÛ¶me5:–bc׿gŽð<3íwízE.óç#ÞƒpþZfýmß¾]­­­‘ën³PÑ'QeîM&„ï%ËFV±EïH*»‡¥ÚCß‘=¯µµ5fx6ŒeæQg2^=ö˜ššš´eË–¸>ˆÌ£ãm7Þ“ç´zÀ®IÆÈênäo>PÄËøScƒ]óÇÅŽ%óÉêcöEœJ²e|†µÂº`M¶¶¶Æ®Nóu)”#ÛZ—Nt{zFÇáƒÌÕW_ýÁÍ›7;Íæ0ÆÚµkcÛ/"!¤¡ØB"g¤+mj~~*מ¦ˆBL¥R±S¥íØ‚V ­è”Añ+›B[M …––555ittTCCCqÎcS66¦±±1µ··Ç1ÄYÄÐÄÀæŒYzéSßBWœ‰‰ uww—eÓldêœå¤ïܹ3fZìü¢“¶[Ê”9Ö …මTRœ¿Ü“uH–…q‡aÒÞÞ^YµoÛwžè$¿ÇèƒÚ…#W,ã Ö¶ˆœ5ŽãÎZAîtïâûqhmfÛ¾×Ü—38R©”úúúâ|'œÉd400 åË—Ç  ž ®º¥´Q€~²E¨¶§Í:±ÈÃÊÆœUWWW¬‡€jÄÿ™çãã㚘˜(;·‡€yd‹Žyîù$æ ºo||\CCCÑÐÐP¬w‚Ö××WÖMueð¾cccQÿÓñ¥¡¡!vBÎók+ÈÎ2ëêêÔÙÙ©\.§£>º¬¸”yË8XJ*{ ßC‹}gff¦ìÄoÛwbb"ê)2PÕ2™ŒZ[[544¤B¡Okfò~èÍ—½ìe•˜Ž*Áºuë<2$`ݺu‡ú‡Ãáp8‹ïUäp8‡ÃápT)ܘw8‡Ãáp8ªnÌ;‡Ãáp8UŠÈ™÷ö”‡Ãáp8Gõ`íÚµ{.€µ~%?ïëçæÏ‡úûûçCýý‡ûóVúó¡þþÃåÔχúû—gÜŸŸõ÷îÏ[éχúûã÷糇úçCýýûóŒûóÙ¥ôó¡þþ$?Ó-Ìi6‡Ãáp8G•Ây‡Ãáp8‡£JáÆ¼Ãáp8‡ÃQ¥pcÞáp8‡Ãá¨R¸1ïp8‡ÃápT)ܘw8‡Ãáp8ªnÌ;‡Ãáp8U 7æ‡Ãáp8Ž*…ó‡Ãáp8G•Ây‡Ãáp8‡£JáÆ¼Ãáp8‡ÃQ¥pcÞáp8‡Ãá¨R¸1ïp8‡ÃápT)ܘw8‡Ãáp8ªnÌ;‡Ãáp8U 7æ‡Ãáp8Ž*…ó‡Ãáp8G•¢fO !,ø³Ãáp8‡Ãá8ôˆÆ¼ëÉ‘J¥\^ á²J—Ur¸¬*ƒË+9\VÉá²J—Ur¸¬*Ã7Þè4‡Ãáp8‡£ZáÆ¼Ãáp8‡ÃQ¥pc~àéŸäpY%‡Ë*9\V•Áå•.«äpY%‡Ë*9\V•Ãy‡Ãáp8‡£JáÆ¼Ãáp8‡ÃQ¥pcÞáp8‡Ãá¨R¸1ïp8‡ÃápT)ܘw8‡Ãáp8ªnÌ;‡Ãáp8U 7æ‡Ãáp8Ž*ÅbÌ—Ô÷¥g(•Jíöß™ŸÚ ÂüËgzõ_»Bç¬lR*•R¦í=óÊ›õØô>\v衛ߢ眰L©TJµÝkôšÿXƒÅÅ}ã}Fá1ýýêÝå4û_V¯½sÇ® +iiL?¿ñ*Bóì5™œN½äÏôÍÇ&ç}yPþuå3zTŸJ)Õr².¾ö6mœ:8¯¾OH4¾•Ì¿„2Xâójç¯þQ×\þ­9nטÿΧµq·…–ü:‹â–/é⦔R©'é/*_”‰ï·Ää—ì¹ ÚüÍwè’5'(×8;ÒíOÖóßöý"öáºrìI®É×ðâ#™¬®¹R^¿üçêžwšV4Ìþ½ùøgéÊOÿ†Kûp?©úd•XçW¸^“ìÕ&+©Ýquyc´èH¼f*™/I÷þ„×-¡yu°Ps¨ààât]sÓ{ô;ü»Fgu)c/)öë[r–.ý‡)Õûõ™³ºUìý•îy¨Oã¥J¯+jÛW¯Ð¹¯»U¯ùˆ¾ò‰“µã'×ëšw=W—„õºó]§¨þ ¼uEÈtëÒMÝvÅíк¼QûõyzùiMó>°7™ÕûÍ×êü7Þ¦ŽW}X_úÄ™jêý/]ÿgÕ+Îß¡=t½ÎkÙu嶯éuç¿Qÿq›ôw_{¡Úþ÷‹zÏŸ¿TÎüT÷üj^Ä×Þ7T:¾{ŸÉd°ÔçUÐŽ_ܬ¿³U§ž{±žÿ¦îÚ¯ë Jƒúî{®ÑkÓÒÎ}½ßR“_Òç.hø×©tÊKôö×®ãZ Úz÷?écŸz½Î}¬Vÿ{Ûå::SÉu{”kò5¼ø¨tÎìeÍÍüV·üùßê?;_®×þÕ[ujn§~ùéãoy¦ÖO¬×]×<¥Â5\…²J¬ó+}Âý±êdUî8 º¼â}y‘xÍ$Ÿ/I÷þ¤2]:óê âÁ k×® ‡7Š¡÷æs‚ê^nÝó•cw½1tkyxéW¶„™ý½nê—áƒ'+茅G¦wý®4¾ÿúΠÖW‡ÿ©üM F¿.oWh~Ù„¡¿L*Ó¡ð¯Ï« Zù§áž ~W ÿò¢Ð îpÕÝ;výn2üâý'Õ<+ܸ©°ëw;ÂÏÞ}|PíáËü{í/oRY%”A5Ì«R1”B¡¸-|þ,y}ذÐBIzÝ.äïþ?aUË3Çÿî¼ÒÉầ*¿ßR”_…r˜ÃŽðßo;:HÏ _îÝÓÙóu{–kÒ5|HV ×\q,lxt LÛßM?>uV*¨ç­æ}´¾;HØ×yµ ÎO~¿dûhÊ*±î8ºü‰Æh±‘xÍ„„ó%éÞŸôº%6¯Ö®]ŽšÍBiZ;' Z8Ù<ªŸ~ò+ê;î*}à÷V‚J ^˜ìºH?øµ´êÅéØÚ]¿LµjÍ+ÎRýè÷ôÏëbjl?0r÷Zýûp«.yÓyjOíþ÷=Ë4Ìþ¾)«e1|•R}[›ê•Qmz× g6ë»·>*u¥.‰aÃ&=õ²W긙Ÿè–ûÆìKìËøîQV ePó*•ÖSe߯“¤©_éú7ß Ú·]¯×¯ªÛçû-IùU"‡2Ô*wL›$=ÁúKpÝ^åšp ,T(«=®¹t‹Ž[•S­ý]íQ:û=ÒÐ ÎTx¿*—xBŸè~I÷Ñê“UbÝqtùÞöåEC%k&É|Iº÷'¶–ؼ:H8²ŒùéÛui{½šk•n?]/ÿð÷Ôk³VStç}ãj:õÝýö³Õ™J+“®QÏ3¯ÒÚ1§¼“^WœÖŒ¤Ú†Ú² ®kPµþáÍ£˜-=„aýä†Û5Ö~©ÞpNëîß›LÕ¦óÞò åù„®ýܵq$¯‡ÿMºæ›ÚqæUºrõ®|õÔ&Ý»Iê^ý$µšYYÌÓu¬¦ôè/ú4¿dá£ÒñÝëüK(ƒÃa^UŒ‚6~éjýußeºþ]g¨iôqÕ˯¨ÉãÊôêáï}Jïüȃê¸ìz~Ç|užäº$rM¸†—"öªŸ@¡W÷üd«tÜY:®¡ÒûU±¬ÀÞtþÞt¬FY%Õ‹­Ë÷wŒ4ö´fö†¤²Jl#Tá¼:8B8ó)ÕvŸ«×¾ãzÎ9ORWºWÿsËGõ¡÷?_ëGîÖºž£æ”¤™!m’&¾ýV½ã©¬þˇôäéŸií»Þ«×?{\߬K;Ò‰¯K5Ÿ Ó:¥›´^#¥SÔ•–¤imúñÚ!i|{^IOc\Cwé†ÿWǫߠ³—Û¿$”©Òêü½ÏëGŸ½LÏyó³tüŸÎ~:ýÔ·ê?~ð^­fáòê—š;›Ë8ä©úVe¥ßnÏk‰ÔvF$ß„²J(ƒºÃ`^UŠRÿ·ôîk×é¼O~YÏmKi|?îUõërì»zyç‹tû.ï¶ý¢ÿ§;oz©ºçóà\—L® ×ð’BRý4EmýÆ;õ¾Ÿ5éâ›ÿHOª«ô~Õ(«r<±ÎOˆ¤ûhÊ*±îXd]¾ßct@ñDk&!’îý‰m„ê›WGg~û¿¾²-¨öùá«ÛwÎò߯nQž>ñè±kâgׄã¤pÎ?l…J® á¾kO Rwxåçî ç‡Ã£ß~_8»AARxÊß<\Î;[r(…í߸84¨+¼ñÇã{¿|!™†bØþí? '§ëÃWþ}øÆw¿nÿÒuá¥+jŸöpO~×u÷† Ò 'þùú0iï9öð’F…•o¿7L„¥†ýß…d•XU4¯’ru÷t]i4Üuõ1¡aÍÿ ï¢rÜvÁœùDß»„å—D^…¡ðàO~~ðÝÛÂ>ty8µF¡ý÷þ1l˜ÿÐ{».±\®áƒJyà ê'‹RÈÿì¯ÂïÖ*tÿÁ×ÃÖ—ìõ~Õ.«„:O÷K¼?V£¬êŽEÕåîË‹Š„kfO2M*«Ä2]¢ój±víÚpäó!„‘o½84¨'¼*‰‰{ÂÛztüµáþæÂü÷ÃeË:¯üqØQÉu!„0ñpøüžjg©ªA::¼øÏÞž¢T8ïŸúÂ’žVÅÞpËóꂎº:üwš‘Ýd:¹>üÅI 5ç!l1 }bݵáeÂù_z<Cˆ²ë¾ê§Á~U©ÿ«áYR8å¯O`¶ZìÇøî&«JdP-óêóS¿ú›°º¶'¼áÛ›ÃÐÐP þéYAZ®ýioÎOïþ¾{ûÞ¥*¿Š `‹áñ[. :*\ýß{rww¿.±\“®áƒŠeµÀš3˜|dm¸¤U¡ñÙë[ßl$^‡ uþžî—t¬VY%Ñ‹©Ë÷a_^,$^3{qþÉ*éuKu^-"ŽÈX‹P,¨¤”R¤[ëÑÓOHI¡4¯¸i¶€'EáDÒë$©ñÉzýÍi|à7úÅýióØÝüœ^mщºðŒ¶},z;8(õÝ¡~8­•—ý‘V'ì|µ›L§6ëg›¥£Öœ¦œÉ5®:W'fŠÚôPŸf$©þX=ýX©ïG4jH‚S›ïÕF5è¤ÕÝK“ö°ã»ûü«@U<¯*Åô¶ûõÛ™mºñ…Ç(›Í*›ÍêøË$é1ýí¹+Ô~Ñ×Ô¿çêÏÝqØÈ/­öÓÎÒJm×ÿnßSUÉî×%–kÒ5\ØmÍíBaÛ¿èMÏ}£n?ú}ûÖ·+i§¿}ÖwKû¢ówCÒý±Ze•Dw,¢.? ct°¯kf7$•UÒëªu^í'Ò©ùZí°DI3ó ×…-ú÷ÏÞ©éúÕzöñ»HTé÷š5ÒÆïèŽMsýã—ÿ¦Ÿæ3zʳV©¡’ë"RªË¨ÓÏxŠVÖþZŸ¿îVíXóf]^1¹ì`¢¨Ç¿sƒî*§?øÃÓ´{ÉHB™Öæ´*'mýŸŸ«ß\?ñÈõHQê\•›-ܨ=F½ôDéžõ(›Ð/¿òumª=W—­9äÄÀ=`oã›TV•Ê çUåh|Útû÷îÐwÌýwëO—´BWÜx»þëÓÏÛÇnÕ&¿’Š»UÃMkó¾£GÕ£Õ=õ]—X®I×ð’BÂ5'©4ôC]ûü—ë‹áµúú­óÛŠq`}·$±7ŸI÷Ǫ–Õ^tÇ¢éò4Fû‰dk&!’Ê*ñuÕ<¯ö5œ"vXcòýÅ3/×½¿ó]°úuf¶ëÞ¯}RkïšÐéø.îàýktüåÑ›þöB½ûE¨Â/Ó“§îÕïý¤¶{µ¾üâî]í’^4òýwꪯ5ëwÏçšk­}©ª˜²¬T't@4±¥QƒmÇ¿ ´†N‡L ô:¢FÁ/$1‰Ä#I7¦AlˆzPèî¿NŸt‚EL¼aŒ¤Ë $»ví½öºÌÛ7ï÷Ù,c¹ËCk¶t¨žïEUí½Öœß÷~ï÷¾ÏxÆ3ÆÛív; âßì øÿ 80p`0 àÀ`@@@@@@@À!À€€€€€€€€C €†@  80p`0 àÀ`@@@@@@@À!À€€€€€€€€C €†@  80p`0 àÀ`@@@@@@@À!À€€€€€€€€C €†@  80p`0 àÀ`@@@@@@@À!À€€€€€€€€C €†@  80p`0 àÀ`@@@@@@@À!À€€€€€€€€C €†@  80p`0 àÀ`@@@@@@@À!À€€€€€€€€C €†@  80p`0 àÀ`@@@@@@@À!À€€€€€€€€C €†ä7û^»Øn·:;;S©TR,ûf_N@@@@À?»ÝN£ÑH§§§ŠÇƒtˆ0àÆÙÙ™îܹó;Œ€€€€€o¯¼òŠnß¾ý;Œ€o ø†Q*•$Iív[™LF‰DB‹ÅBñx\‹ÅBétZ‰DB›ÍF›ÍFétZ³ÙLétZù|^£ÑH«ÕJÙlV»ÝNù|^Òµ²8ŸÏ%Iñx\ËåR»ÝNñx\ÛíVÉdRëõZÛíV•JEÛíVÛíV³ÙLñx\étZóù\‰DBÛíV›ÍF©TJÉdR©TÊþŸëZ¯×’¤d2©Ùl¦l6k?³Ûí”J¥4U©T´Ùl´Ýn•J¥´X,$I…BAƒÁ@ÕjU‹ÅB‰DBétZÅbQNG¹\N›ÍF³ÙLÛíV‰DB±XLËåRFCÛíV¹\NNG‰DÂÆ1‹ÙýKR­VÓh4Òn·S¡PÐb±P6›Õd2±kšL&ªT*Z¯×J&“šL&ŠÇãJ¥Rvܯ${>‹ÅB™LF›ÍFÓéT'''Úív’¤X,¦ù|¾w¿Œùz½Öf³±ÏJ§Óv½‰DBËåR¹\N’ö¾cµZ)ŸÏk:jµZ)™LÚóÎd2J§Ó’¤Ùl¦år©|>¯Ùl¦T*¥\.g÷Àçó³Ù¬Í!~&NÛÿ§R)‹E­V+M§SûT*¥ÕjeÏ‚ñc>u»Ý½ù‹ÅT(ǵ^¯5›Í”Ëå´X,”Ïç•Ëåtuu¥r¹¬T*¥T*µ7§ãñ¸’ɤ–Ë¥V«•jµš¶Û­v»æó¹Ÿ‹Å”Íf•Íf•N§µÙl”Ëå´Z­T­Vuqq¡££# ›ÅbQÉdR«ÕJ»ÝN±XÌž[±X´1–¤^¯§B¡`ïZ&“Ñr¹T"‘Ðl6S2™Ô|>·9>›Í”Ïçí]¾¸¸P>ŸW§ÓÙ{ŠÅ¢âñ¸F£‘=ûB¡ n·«B¡ z½®Õj¥D"¡Ñhds‰ù¼˜Íf*‹ö1ï—Ë¥2™ŒÖëµÙd2Ñd2±y‘Ïçm÷û}¥R)¥Ói¥R)û,æÍn·SEj·Û ‡ö³Édro^& %“Iõû}¥Ói[Ãx†…BA’ìÞƒ2™Œžþy=xð@çççJ&“*•J*‹º¼¼T6›U<·wzµZéøøXWWWÊf³ J§Óv¯çççjµZJ¥RF* öìY‰„†Ã¡ªÕªúý¾Ýïv»Õ¯þê¯Ú:pxˆíXåþ…‡ªT*zÝë^§Ùl¦Ýn§d2©d2i›Ùv»•tMòù¼&“‰‰„¤ëMšMi·Û©R©¨ßï+‘H(k³Ùh¹\*›Í*‹i4Ù;U*•lsÚn·¶Ñçr9Ûðùóù|®|>od§X,î¿Õj¥õzmä ²²X,”J¥Œ¤²apÍü\,32A:²Àµ,—KÛÐóù¼=Hã’L&5 ”ÍfU©T44B‚¤ëÍj:Ú&7ŸÏÇ•Ïç` ‡C#Z\7?Ë÷sÝëår¹GäØW«Õ^ª?ŸÏk±Xh³Ù(™LaL¥RFˆ·Û­}ŸéçÇd2Q¡P°Ÿg´Ùl”ÉdŒN&%“IÛøW«•9ϵf2oþÍ÷BîK¥’ý¹$#‰<ó««+#_†x<®R©däkŽÇãFf úëõZårYÛíÖˆs"Éû‘Ëå4”L&•Ëå4íy&“IµÛmûüÝn§õz­z½n×_,%]tONóù¼Íu‚+ÞS<ϦP(YFF²ŽŽŽ,Y,ª×ëöN M§S ^xˆj»Ý¶÷%+—Ëi¹\ÚÜà~˜»¼;̧Ñh¤X,¦Ýng÷¼^¯•H$E‘‹Ü3ÏÚ?çd2isŒ T’¢(R2™´¹M`Ùl6ܦÓiÅb1M§S¥R)›SÌ«Éd¢L&cAã`0P¡PP6›Õt:ÕÓO?­‡Ú;>Çmž ‹EÇc#üxHy*•Òz½Öjµ²u’5%•J©Ûí*‘H¨P((‹Yð‹Å”N§uûöm½ñoÔÛßþvEQ¤r¹ü„»AÀk!ñðÄ@5€@ðgDȹ\Nñx\ãñX™Lƈ‹›`¿ß·…yµZIºVoÖ뵦ө ÕjeÑ5›j#ßí7cH‚WSØ ¸ÆétjjÅd21ˆÏdf³ŸÏçö™|›n¯×3R‰êÇÍçs•J%M§SÇc­×k[ìÙDPI ;³ÙlO=dCâÞQd$i:j8±+ ¦°²q š€ÍfcŠ!c áa“ã¾NÒõæ‹Ålã–dd/•JÙµCB‹…ÍHÍd21²ùæ÷ëõº‘©R©däÄ+\ó ÀóœÍf* *•J¦>Ïçs#é~³Ǧ¢°áÎf³=uÕÏ)”î‹ÏFuÌf³{ó B/É”¦Á` T*¥jµjD  Ò\­VíY V–Ëem6 P¾b±˜V«•-ÔZéšàs-ggg*‹Š¢ÈHW¥R15:›ÍªÕjiµZi4™:i‡e³YYÀFÆxCÒPg³™=·Ñh$I6‡˜G“ÉÄ2 \ûjµ²÷úêêJ™LFÙlVÃáÐæÜl63ÂX­Vm~ó¼Qªƒ½«ÕJóùÜ®y<k»Ý*Š"­×kív;år9›O•JE¹\N¥RÉ‚ƒR©¤Ñh¤l6«Ùl¦Ñh¤Åb¡h±Xh<k³Ù¨\.+‹)“É(•JíÝ7ó…˜õU—÷¿\.Û³`m‚ŒÆãñ½¬A‰W[<1 $D½(, !"y”R\ù|^ù|Þ6FI¦b±Á¢dx¥† —ô3jÄb±0•Å µ†ëô$ å£ßï[´NZ‰ŸgÑG!Êf³Z.—Ún·šL&’´—"…DB ¤)œA…k6›v¿\{*•ÚÛP7OãòÝüž$‹EÛØ!/¨¤"!ž Lñ9¹\ÎîrÃ5ð÷>=ÈçÅãq M§SÛ('žó$—ËYÚn>Ÿ«X,j2™h<› –ÍfMC, Úívê÷û{é,6k~—ôè|>W¯×S¹\¶4\:V¥R±1d’Z†4¦R)•J%EQ¤Íf£áp¨ét*I{)@~6N[:ßoÐårÙ>×ÏCÆ¥V«ÙŸ“rï÷ûf)@MG!Gí½ÿ¾Y¤ë j»ÝšÒ¼\.dGQ¤B¡ ñxlcæça©T2ò ñ]­V‡ÄãqM§S³}Œ,0¯J¥’)ù€€n»Ý*›ÍªßïÛõ¢"B¦“ɤ*•Š©ü(\³Ù̾Ÿ /«Ñhì­OWþŸëâ]¯×–6†Œ–J%år9STy·!äÒµ-£ÛíêììL³ÙLNÇY®u<k0hµZ™ f¹\ªÕji±XXVd³ÙñŽÅbj4*•J:;;Ó£G,æ>–Ë¥Ýûz½Öå奥ÊY3¸^ÞF£¡|>¯¯|å+ú¾ €ÃF €O R?¤±2™Œ-B¤–ð^Apؼøûù|n)'I¦T \ ²°¡z/›Q¡PÐ|>7ÕUŒ4é.RoDÃlnlt¨^ÆÉdbiTŸk<›‰k!-•ÉdìÞP²üXz?¡$#@ÓéÔÔ;~6™L*“É©#ŸÏçH2î(™årÙžƒ$#¤IÏá§d“Z¯×¦ªà߃رñÎçsM§SK‘‘:{ùå—uyyi*¡¤½4¸÷¯yï"vî V’ý7Š ‹t³é£œd2µZ-Åb1µÛmKsݨá^9õv†õz­N§c*>¸Á` Á``ÄæŸª®/‹{J8}¹\ªÙlªÙlÚ3fÓO$ öòì¸n®—@€':¤±*ð>ñóX,¨0åYà]åºü÷2vívÛæ*ײÝnU¯×ÍGÈõ‘úÅ–yC©ƒPye~6›i8šº‡¢Ù?==Ý ü|J"Žd<›ßÓ&ŒïB,S¹\¶À"îƒQî#›ÍªÙlîÍÝ|>¯F£aï{»ÝV2™Ôh42«Ër¹4ðáǦÌâ¡D­åÝÂkÉŸ. xbà=ƒìà•’nÔžX,f)”/”¢ei£–áÏaSN$ªÕjF~$CyÊf³¦˜¡"@6ø™\.g›©W·Håø¢„ù|n ;~©|>o©èjµj©OTN"{È%¦n6®…€±`“$=‰…Xów«ÕJãñØ”3?fÅbÑÎf³± +Š"‹E#`¾8D’]›9÷Íø”J%ÛœI—­×kÇcÛ”!þ ÌòÞãE 1£¥ÙlÚØ÷z=#u¤¿HyB<ðrñyÝnWårYÅbQ•JÅ”È)j4vþ|:ª\.[ÀÑét,¶ÛíÔív-ð€œv»] hšÍ¦‘K?‰„Š„âñ¸^yåµZ-•J%µÛm»ß««+#m^=ƒôAx¿°[p}ƒÁÀR}ÕjÕH)æù|®W^yÅŠW‹…J¥’¥Þ ’˜¿½^ÏŠ»Pê°v ”% •Ëe#D¤…QÅQպݮf³™ H'¤”÷g³Ùh0XpH¡N*•Òt:µà 5Œëå9‘bF­Ç²Q,í}Åbêt:æc,‹è¡,f³Ye2³ox‹D‘Âé¦`+‹i0¨Ñh˜ªÊx@*!¤ý~_½^O§§§º¼¼Ôx<¶ôúb±° ˆUºQÛ!{ÇÇÇJ§ÓFöþb¯ x#A`p¸UÀO ªþˆ\QÃPóðÄ e³YóSQH!Éþõz­R©d‹›ÞÒ<tEfêŽÅb*•JFvX}ÁGEªT*Vàÿaón*g‹Å¢m$RLÜŒŒF#U* ŒÝxÁ ¨ˆ¢D"a„©P(¨X,Z”²ÂfÏXrmÅbÑ P¹ßn·ké7Æ’ßó…¤1Óé´Jž%Ÿ‹2ÂÆç`ÎO¥RúÖoýV½òÊ+F QV¹¾ƒße3’nªc!Kx´[646oŸÒCC1‡{Dš´·¤=o •¥a6ÒT*eEIŒ/$†±a‹EKÅq=(ˆ¸““+ØÁšÀ˜0Æ©TʈÕf³Q©T2U›wh2™¨^¯[3¤ ï*ׂRŒ×®T*Y*]’^ÿú×k2™¨Ñhh·ÛéììLív[Ýnׯ‰ë‚âC‹¢È*±)àñãï=ñF¦’Çw’fn¢~zï#óÎ[’ɤÆã±ªÕªjµš6ˆy2™ÔÇu÷î] ƒ=/²$[3J¥’Z­–YÆã±úý¾Z­–}óe:™n6›Š¢È‚]Ö¯žRœ“J¥¬ÊºÛíªV«™ Ç3¼ó߬QÌÏL&£étjV‚Á`` $äŸ@ ƒkc~R`Â<8l0à‰AÑ5j›Ã`0°Ti¢X¯”@ºHÙ°QP%'ÉÒQ€étª|>o›j ›Æ|>7•¿ƒ(°aúâŽD"¡L&³W$á7.T#C¯×S6›µÈb‹º‰ÒÆçB`øó(Š,];™L4 $iOaƒ˜z%¾K|D¤Q!(^Ac\ ̨UÓéÔH…ÕûÍðÞA ƒÁÀÒÙuHûm~h§ÉDEô©5_l™c QQs¹œm²¤U³Ù¬)-Œ)~C6ßt:mÄ€6"‰l6»—f÷•Ä¥RIý~ß6ZÔˆN­VS¹\6RË|*—Ëj6›J§Óö,ðZB,© áeþ`Óàýˆ¢HãñXÓéTO=õ”uà¨Õjö¹¨w¨¤–AØl6zôè‘6›ÎÏÏMeä>¢(²ŽŒ)ÁÊk[EŠ¢H’tzzjäy·ÛY015u~~nä•z:ªÓéØœÏd2ªT*¦þÍf3{OX/˜³ÉdR§§§ÊårªV«æ}d 8\ðÄ€øÑ“‹E‡T‘:•¯µù|n¤N¥›td˧0QIQQeñÁãCï+Ô>é¦p„Í„J=`ªj%1ó*$ê¯Æ…8ÆãqÛ\I}¡Î@ZQ>¹*U!=|¯÷8AÖh ú¸7È?ç{}±1J²q‡¶ùNå³¼Ÿ bF:ò ±c#Ô½üòËö]ö ìàÍÄA„r½az¢n2fú@X¨xFM*—Ëê÷û{›£OéqM¾øk-< £o~ó›- ñªElêÉdRgggŠÅbJ¥Rºuë–/ ‡C+ÂẸü¨gétZwïÞµ{†pq Œ5ï÷¡fŒ™Ï=÷œW"‘°3ä¾T*éÖ­[:::²"A„µX,Zñ€¯æ÷g³™åÐ6E’¥ò'“‰õßk4* Š¢È*p;޽WX:Ž­øû(†áßM&󵈴Z-Õëuóòù¼ã·oß¶t0Øw£Â F#›÷.‘HèôôÔÆŸûÅGX,­*7Š"žžªP(˜à„ ß÷J'Öæ*ET¹\N•JŲ ­d ðóñFQ´çµ¦à‡w ;GÀa#À€'•ª¤0!]étÚHU}ÛíÖŒËl~’Ì+HôŒ’F´Œßo6›YÚh±X(—Ë™_Nº©ÈõMŽù~Eï5ŠÇã{U¾&”'<@|Í_“ɤ¥eÚí¶kd2S?H ³1²öz=#Ü+äË·áïðÒù¢Òèø§ðÁ‘"„ÌP@Aalؼ}Ä–jN|C>]‰ ò×+Q¨Mý~ßRð\#+ :Ž¥d£(2Ò·^¯í³yþ¨ø%™Šç Hâãžé)ǘ²yÒOyR½X,ôú׿Þ<žs_­^*•̨Oúm>Ÿëë_ÿº½¾%Žtcu ç¥W77›...LE$õ’g‰âW©T¬ýmAjµšUÞâ5Ä?JÁw’²ä¾½JKá<ªI!'£ÑÈÞÞ±Õjejc†¢–ÍfU.—­• ðÙgŸU©TR­VS­V³‚qCi¥W"ï;cŽ’Mêáx<6"ÈõGQdm“|ꔹ@Å<ŸEL¬xìÈTL§Ó½&÷¤[©øF,•Jº¸¸°59IðFà×n·•N§U­V-³€Ÿâ9H j"÷P*•¬XÉ÷ õÕ¬‡Ð:à ïܹc ’÷¨¡ò‘v$ÊEå8AƤ›BxïùA=ôÑ:©TŸJfC€Ða>÷¾1Œâ´c UŠO ù cÒt¤ ¯úe³óç½Cóù\FÃ@Ìßl¸.š6K7^5ˆŸ$û=ŠVP?È¥W=QÜH'³áH2¢ÃfÁF‡ @x’Ì3¤¿)(ƵçIÚTº9ÙÅOå〈0†’ŒP\^^Úüi6›–šöýyþ•JE½^OGGG¶Ñòݤ‡ÙHý¸Çc5›M+$ŸʜBf¾@Ô!"¤Js¹œîß¿oJs_*EJToRz||lïP­V³žzÌwT†g³×ÍÃ;ޤøÆçD¾ßl6S¥R1O ‘çÆüǃÚh44ìý‡V­‹÷’ûâw)æÈf³j·ÛFH¨è¾ººR­V3bIšÅOðd21ëJ[£ÑÐr¹T¯×3Êñl6SµZµvB:Ò«’¬x„õû6ª”I¹rM’ÌÇ™Ëåt~~n½ ëïÝ»§J¥bcœ£uÕxñ‰Ðú€À€ L‘–`ヨBƒ˜ ø‘ºÀxƒ$²xyòF:Pº)`Qí÷ûåòw•Jż;˜¶ù.¼;¤r!ZF®S?*iÔ*6ˆÊ×ÉfÅbÎwB¬hæJ:ŠjiŠHPÕPPHýr¯½^OÓéÔRbl¨´Au âÄŸ–Àsa¢ωûãÏ ÉdÒ ±$ózAȨè%}‹GÍ7d–^í¹\­V¦ñìð[u: |:BZ,-UŒ€†Û|Ïbùx…7sŽïæs¤›Ö>ÌUÒÄÌ‘Z­¦““#pô‹#íŒzŽwËsè+N—Ë¥*•І½7¤©¨¦š¢IæY¬T*f»àùùÖ5§§§öóÌ3IöÞ ¢PCJ™=±&pm¤“G£‘–Ë¥:޽ÏTÍrê ª9d«ö!Þ‰Ñhd§¢@¼ñèá;dŒ!CXP\á›8SuÌ}òYÞ²2™Llžt:ó¥Æã7ð0³ž@ÚHç“jf>Õëu#q©¬—¼7ÞW‹wÐÛ<¸_È5ÏuÝF& xb €á'‹¢hÏüͱI¤Kˆj}•' m$Ø8ø]Š ¼ºFk•t:mé?šýrz›2ä‘~f ¯(’ršN§êõz–V“nÒ%™LÆZŒx•¾}ËåÒ6TŽÂÂçEQé# f|ãl®£V«í¥wQ?ØXì“x<¾×æ¤oNÌï²1ûô6)7¯NH²Ó ¼OºI­“Þålgj÷Aê![tÈ8Š1žûñcB•4)¼““år9k=‚ø1NE*QéCH5$ ¦'·TZòÜi@Oœ)6ádzÓ=îw„”£èQM/Œï¦ ÛíšWÕ7“FÍÅ6±Èårê÷ûÖœ¸\.¹ƒàÓ*¥’w ¯*$‰ô4óx±X¨ÛíÚ| Õ‰z É‚À$õû}{¾ÞïÖh4ìw±a0>¤í™wÛíÖÚ´ÔU«U+V)—Ëö¢è‹EÕëu{þ‰Dªž™ƒ(ÖÕjUçççö=4go6›V\…ÒÎ +Œë„Ÿà_1sžs†½=ïüüÜvÆ)“ÉXà³d®ÇãqÕëu#±ÅbQGGGVHû écmò•ü‡‹ø†A èèèÈÔkZ.ÐéŸH›ŠQ7”Ÿ:&UAªÕjŠÅbêõz¦@þ ’J¥b‘;߃R!!m;ŒpùêaÈéS"~ªPùoRƤg RÛ¤¤¨lÄ͘H²†³øˆÎËå²¥ÕXÀ!¶l2¡óóskšì58ÈŽ÷³‘Ò†ÄC–QGøoî Uê wü1I6'xö´Ó¡š•ôÄ ±õE;¨¾šÙŸÂB.×ëµåÐ^ħÉx>x&s¹œ¥ûP}iHn«Õ²â’jµºw†W¿Q¼ 5Œ³÷mA|j‚ é^¯×:>>6•š¦É¤Ý!žä0VNgïçÓé´Z­Ö«Z× îqL'è@Qæ¹_ßÈ™g™“nŠDhGT.—ͳX©T,àñéVæS§Ó1…“t²?Mˆ Žà€K^Ñ|>¯^¯gï[½^75 ÿ'„οƒ|'í¬ S|&ÊëÕ·’̣ǿ¹F_¨Ã;Žu†N Ùìõ‰(´ÜAÕ%sÀº3M9'µÉd,…L à çð?ówãñXŸþô§C ø€Ê€ž¤l|¤L$²±ÇVÅ'ÝœgK?/ˆª©/ÌÍT² ùƒ¿—n€A•ãù2OHÝâåg}jR„ZÇÏQ áÛ:á“„€á/¦ˆˆô)…¨­¾')OÎÁ¦7¦'Bô|ôè‘r¹ÜÞsAe…\âÝíõzfa¨Õjæ©ôó‡û”¤óósU«Õ½ ê‹‹ år9K“ á¹±NúyLå4󞢛‹‹ «æÚ)*am%íªÎó 8l„pÀÃ{ŒØØŒ¯¢c3‘dJÎp8´~¨¤Ùp‰X}ËßÝŸT)žpøÜøºäC4 ¾í êê—$ëQÆg³Q¡v 0aìF¹@ È/É"t›: •ø š@®ƒ¿C]ò‘¤ß¤›ÔÓnw}^.gªR-Z,÷Rµ>U!g#"U ‘…ô¢¬ðݤ|³kIæã9Ar QgîÙVpl`pžd“”.ÏöââB½^OËåÒî ì;wîX?7¼`œV‘Íf­­Eý~ßžÁùù¹¤›“DP“Pg¼b |*Ýß}ðð³RTà dŠÅ¢¥¦!·¨¹¨K¼W¤@=áç¥= 7*öéãȳ¦Rÿ,j7ʱüPi§Ó©;æÓï<Ór¹¼w „âBãoNè Ñ7=F}Ur¯×3-ä{8j0Ø<Fö<©œ% »Z­trr¢jµªV«µç]l4jµZŠ¢Èü™ô˜$ˆCá¥HˆµgµZ©×ëYk,‚KæÁA¡PÐéé©v»ïT«U+2"x 0ˆ@’ îgžyÆ6El¾±ÍW­Víè4ï+Š¢È*i%™—‹ˆ>,RIDì\3© 6F6r|k¤î¼×ŽÍY’Ý þCÆŽï"ÝÑá³P7ßË ²êÛÊ ìAùÇ{È0˳ù¢b@Ø4 ka€ I\¯×F8 %Þë‡j‚ qCÍ%%ÁF-äω„J¥’ãÙÈ|Õ4?Z¯0¿|Q>I?PÞP^‡Ã¡žyæ™WùôhÒh4,˜!h€Ìs˜W×Pêx–ÕjÕ¼²Üj+J¤•›*aéZ!cœ|š1NëêêÊ<°Ùlf§O0Ï$Y3hÆÄû@)êaœòù¼ƒ®®®ìt’çŸ~ï |}T°R9닽(Vò¾[º&ô¨Á´•A)§0ˆyÆq}[_@…ÇXÒZ…y^­VíóV«ÕÞYä|myxŽX6(*òÁÜÁGÀÌqØIsN!haM[¯×º¼¼´9HÐuûömÍçsÙ‡Ìù9ZaUàY²¾¶Z­ÿÄŠp(À€oxI­±Øà¥b§é96<”U_M‹JˆòÃbí«ƒñ÷P‰(ÉR5}@dH¡}Ì&@zΧIIùáq‚@ª%™çɧÏi׳’nÎ0&­„ïÐWÙúBI{j©4>V·ÛU:V¯×³´¸/þa¬h#ÄfL»Ž^¯gø½ÊÃØRê•kÒ°¨t¨EÜJ'ª¾=H,)vήV«{§ç”Ëå=Â*Éæª7ž@Þ~Žžy4'æú¹&È«'¬´Áç 6R©”ͶX,ì<*Ä!jôÛ;==5¯#*5Õ[Òé´]DŠ1˜Íf¦œ^]]™JÌÚB#ÉúCŽÇcÅb1óÛùç‡?wËû‰„){d&êõºU·Z-õz=«âN§¯ÏNÆ 0Õn·m¾J²Š{î‰67ƒÁÀú_2÷2+þˆB”Ùår©z½n)þd ™$é×~íׂð€À€'$…‰$SDHãÕ’n*iY’¥*|Õ¨¯¦“núÁ±q 2@$Pʆáý9ÇVAþ Z¨¤ˆP*!d\{>Ÿßë‡ÚHõ*›)×ÍB‹Rå[9МاsONNT«ÕL={œ BÎPÿøZ¯HÚg®Ã·q‘´çu¤ €Xùv>õN3dî7[?<¾'[Ÿ¢d< <\/Ï\*•lÃõKÎ1ãB‘o^L:¥×W“ºc£­×ëV˜DZ…µ›¶!%*Ú!TÌ—v»mÇ‹ÅãqóÁ’ ÄÆ3BEѦŸß9&šËåÌBA:õ¯V«™Ò)C£I1ÖæI½^·÷z8š*‰ÈÜó¶”;ÞiHp¿ß·9H[&ާ£Uãí¿  ÂCI±_]]Ù3ñª¹ÿ‚IËdòúx´z½®X,¶—>öÅ^¾B€Æ73¼±6*›/N£Ð‰wŽ€Ô7Å,¿ª›ÍÆA“µàðÈ󹬻¾Ç¿ï\Ä0à°`À#‘HX› Òy,êlèþT ˆ‚oIÂ9¬ÞÌLKÎz Dâ6$ï¿cƒÇÃÅ&ÌßcçdÑJ¥bJ j Þ/6TTNÈ%„Ʀ†É5r,þøý†…Šo *©<”)Úçp jÆ„Ö)>5*É~_Ò^Jrà{ú~gø+½€6>ü<÷é{”á÷¢ß‰Á05U­VÍÇ(ÉR¾oæ"„Ì#Ægs®-ÅÌl K5ÔÔ*®¦?1E’)f¤6Qv§ñx¬ñxlþ5ÈEEØä`m Ð2urrb§ ˜`¤Èt5ï+íHðen6U*û|…k«ÕÊZÂ@üð¡aÅ8::2•™ñF¦ó¤m±" ïµL§Óvr ïC½^W£Ñ°ùGª“y†µÒœL&­ås¹œ©×1ør{½žÝ'ïìz½V«ÕÚ»v¾ÕŸ%AÙ€B¡`g £†36¨ÂßíöºwéÕÕ•¢¥R)SÊ95ȯ“;ßä»Z­êääDñøuÄT*¥‡þkn¯A„*à€'FtŸ"„@ `¶DÍàø6"rOdJ¥’F£Ñ^/2é¦*’Å”•ÒÄçPõç[«øžaé&û¸ZY*•öRM¤ž| ”*ÕÍfcÕ™QY[¼@´Î€2>,ب<¤èh‰AÑ!ÝD{ H6ÇmÑ,‚$iïÄ ¹ÿ^¼P×X,fiCüZøª8݀͆ÞÛ7žN§¦ø- ó_QÕÍ}@Ëå²¥ˆñýÑB¤ÛíZzPíLoµB¡°×km2™X“Ý(ŠT«ÕöÚ¿`3€ÌsÌ=[¾§P(èÖ­[Z.—ê÷û¦Þaòǃ‡úzqqa… ¨RÃáÐH¥oSĸCb3 ×È}¢ª±Ág2U«U Œv»Uªb¹ P€ ñ=Qi·Û©R©h³Ùèþýû’n|cóùÜ*w™/¨ß«Õõ‘hÌS,ô"äyq¦¶W‹…îܹ£§Ÿ~Z¯««+[÷†z½žÙ H£æs$g` Ró3ô"dìñ)s®³o;Åû¡$`Dµ½¼¼ÔÛÞö6åóy½ôÒK¶®18\ðÄ *É"QßþÄ#”þŒ _X¯VáññU°¤ÙHÅ`¬&åÛyxÏZ<~Ý2" Cx ø3”L6ˆ+U²¤¤PÇð‘#-ÊFAZÈŸÓ‰r‡oŠÔ$ýÎØ(|.ž46 T:6)ª21õ{õB’}›*'œHzUJ¼^¯Û¹¾Dßz½^[Š r ¦J’3`!O>M.ÉÚ0ö±±m·[{^Ì62TÎJ¥b›2©{P­V5÷Ž=Ã7E‘îܹcj÷¶ÙlL!ƒð¤Ói/ŸžgNO§SM&«2f^—Ëeõz= X¨äå÷¤ë4G‹Q½IÀˆ9Íæ¿Z­Ôl6-øÀ§È÷Ð×µš”¯$ûlîƒ{e®zû‚ÞPçý;Šzù…@år9YU*?9¥ÌÝ»wõ¦7½IÅbÑÈð½{÷ösÞIÒôŒiV,ZzY¢ŠÆã×m“V«•òù¼=ÿétjj1ã…âO«Ö9¼¡ÙlÖ q j\¾@_üåç×G˜Àm6›Y@ú*B¨ x_°Üð,Óé´µwB5$¾Ûíôñ*—Ë{}½u"à0Š@¾aPB+6B_ü@76IFl¤3>‹¤O’¥´|!$Oª*¡'¾PÅ“Q醮V+Kwñ9^éƒÌ²iø~\|¤Ï&~ˆ!=×ø]6m=¾!­/:`¬%©Ûíª^¯Û†ðEôý‚,CZP]¾"žßåS댅 p?Ú²øvô%ó!þó!X>†êquueg6C Øð)¾ÁgæÛÑèד)4׆·‚OÂÏõL0§!à'*Ê!>Ì%ȧd`Úg< sÒ É€¼K2¢KÊd2v~.ý,iSBÉÑё٠èÃ)Ý@cÞóóî¢J2P¦3‚8ªÃI3_z$Y°pëÖ-žžÚÑyétZ÷îÝÓùù¹.//Ø \“ºmµZVî½­øê8þìììLù|Þy“Æç3§Ó©šÍ¦)ÕxW±P\â[\ykŠ"ê!÷¶^¯í3...Œ(CäÉà•f]bí ×(ãŽÏ–9Ëœ¢8{™ ‚póœ²Ù¬~åW~%0‚0à_¨5lš¤-|Rº93òÁÆ/iO™`‘$µÈ¢Íç?®@Åb±½C”? "üQaÞ¯郠²!¢ yƒz&“Q«ÕÚ;4^’U{Jמ/z|á òjPÚ?H7gæÒf„b R‡ÞOº‡”éÓjµj ß´! à}ú\º9ÎÅ‘MuÒé ÿí >¶ÊPŸ6w3U¢QÙ9ºNgï3 (hxN/Ét?oi´Ì{HE´;™L&FÇÖº‰jS>ƒÞŠ“ù|®ËË˽B¢õz­n·«áp¨XÅv2™´cìþáþAÝnׯÿN¥RªT*Çf€¼3w¹GÒ²ÒM/OÆ€‹EÇcõz=ëÈ}Ñ’Ô?õétÚüÊœîÃûúMH+ª‚ÿ)ß°ʤ›>‘T™³VP°ÅZç›GW*+ ò)k®÷ôôÔÞ]nÀa#À€'Æd ã,¾’öν…ÌàCCqÈçó{'ø¦Êø‹0mãáá;0“ûß%ãUdT&O8ÖëµÇâêOð$¯-Øt((`óÜl6FD Cøt¹¤½BÒ Óétxa*‡hcŽ'MLE±¿Vþ›¢ )’ɤ¥Ú V~ÃÐA®H'ûgÊïp_²õzmêT"‘°êDî Ò4 ÔëõŒ ñ-/ DþwGª }ZÂN]_ôB¾'æžPIF$ÃñxlÕ»ôáã´  o65 ëÕFZ>ŸÏ«V«Ù³ä¸/RwNG¯¼òŠ Œ3'ÎPêÇ– Ÿ€¥V«™ MŠß?×áp¸× {6>¶9ˆ¢OfÖ7­VË h°ª$“IKýCú *ÁðÄ …D¾’ÌxO{ÈK£Ñ°´› ŠoH² ²„A›6 ¾ŠÕ÷óªJ ©¾‘ŸAÕ"Fz†¢Ÿb„ÔBFúýþ¹èt:ö³´’@±££?¿ ”dßÁ˜Bl86ð{¾Úšb)Z¸à=‚An$™Y‹ÅìsÙ@!‡¤h=‰„dSü@úµÁ÷D½¤ñ2$erÀ<ð©|Òð¾­ M¿!!xÑ(ÆðÕ餿HS,@Š2å›e3¤á(´ð÷íS×.æŠ$MŒ™{/P´ñ*—ËV±:™LÔh4lþqTŠ/&ðgТNB†©nµZêv»F( c…BÁz:RÈ™£xÒžÉdÔív­@¡tÓ¦Ñh˜b±ìt:F>yÞóù\Ýn×îw½^«Ó騽øÂ#úb8r* ÁÖ Æ-N«Z­Ú\.—Ë:::Ú+(b¼<¼ººR£Ñ°”B&ÔGÖüºOAä±ðܱi˜ù@‰â/Þ>úXr: g{ÿs™“YPÿy±) B\ÃI A xbøt+ä€4ˆtc"—d½ÓðÑ ˜Ìf3[}u*›# úãhñô°óoÚ¹°0ãÛ" Š‡ßŠ(ß{qP9š Kª²Hº™”-$Eº9•À7Îå~h Â&ê{ÒW RB; 6bîßA©â@N¨„\ñ÷’,íÇs"eÊgC4†Ã¡y¿|jƒ~­V3âE:BE96ÁÛ·oÛÆÄæL“ãÅba­j 3ø8)tAm#]J;Š/¶Û­ŽŽŽŒ42^X {æÄR’z½ÞÞÙ²¨:FCívÛÒx~|™GxU!“’,}zÈ1q(¼TƒKÒåå¥U¹£ù4¾t­¦úöKÛíÖTKÒÒ’ö BP²°90ù]ßÞ…ç³\.õàÁKwCž$Y‹“««+ûÿÅba픘;‰DbïÌhÞOæáp¨««+«ª‡€S8T(ì]‡P1¶TÉúÊ|6Þ‹««+#cFc¯È ËïÁ&ïI»ÝÞ;«›5¯Õj™²Iº}±XXµùl6S«Õ²g‘H$t||l÷ù„°Íçs›¾ψ€Î+îvÌåR©´×û€ë{Üžpx0à‰ú@»6BLæxÀXp¼7L’'Ô_‰»Ýn­‡Ûf³±jTþÜ{«èSÆ¢íýF¾éôz½Þó¿A.}ª …‘ ‹k@µãz}£jˆfuÒC¾Ø…kççiUâ=tzõ‘F¦Úoã‡ú ‰†LÑ2Æo.x1£ûžpK”)ÆŸø.¼\|&—猌 <™LªV«Y gÎÉ |7ŸÁ³ m†zK¥rE–övRº(îŸ9‰b3Å@O€ŠÍ™­¾/%÷ãˆ3ãA:–¹!Ëi¨Ü#ßÿý߯·¿ýíªÕjVµ ñàs)ná9p„]µZÝ«2f’ö*ŒÙ°¨¥åE\„¯áv»5¯Qµß¸}ŠQÒžŠ™J¥öúÙyÒIŠÑûžø½n·kM‡ñ/’ò¢u „†B†l6k›&j ΦÑa³Ç+HA|?ãñØH÷Ä÷K7ž?Ÿ¾„{ÿ!iuŸ±c ©0êŸ?_Ö§¶ $x"}Aó•?yäôôÔîÅ‹`€?“d×団ºðýÞ#Ч ÅCÿ|>ß;7“ÉèèèHßò-ßb­EPÖP¹!B¾2Ô+á9ŒÇãæÍ¤ù3M›·Û­...tqq¡F£aÏßWçSøs~~¾Wm?›Í¬$ çÑÑÑ^a Ï¢×ë©ßï[pÄõКyîûÙ%“×GØ]\\(‘H˜RÉ÷Af(ÞX­V:99Ñéé©)ŒÌ7”>RÚ¤…Qè"_ž=½DéOY©T¬Zv»ÝšÒÚn·­Ãê3sóyñ…J×Êo«Õ²b¦l6«G)‹©ÑhXšžbÖ‹ÕjeÞL2 ¨œžBÊ—1¢&÷‹R P {½^hÚÀ|ã  L»Ý6…ŽÔꛕiø~|Q…ts¾,ê‰tMVðÒÁB Ølü™’ìsI •6z÷wŒôïÿ¢¬þ,k€Ïg3"ÍCTM`Tß`ÿŒ÷²Óóϧ! ’ö* …‚mDž @ö¨¼$õHiBÔ|C¤È|0R¯TÛB¢(2? ¤%‹45>+¿¹n·[µÛm#½øÅð*V«Uu:óç¡‘Î¥âÖ«ŒŒ½ñ¸Ò”žô@Ê}:O„ýÏH2UT’ùyf¾š“MrÇgùþkxS%YK:s ò1ðó‘k¤úõFÚïç„#X,j6›*‹êv»jµZFž$YJÚû/ ¨˜;œòAzÍ7=fœ¼Â-ÉÞoš7Ó¬"ΜäÏæ“Ղàk÷Há…÷êB¬}{Zû0‡gÖÚ¡ðnà£ìt:f-xøð¡‘t~ì*´E¢Å7¼g ò~Q<²ü>Gààpæ0Y Ö-ˆ$ë ¤Ô7©&ýOBîi»½n{s||¬‹‹ k}syy©jµjÍ×;Ž}?Ï Në×ý×C˜F( øW¯låTß„ô‹'Æi¿ÛétŒ€ ¤`®†t‘Ê£½ ‹§øôQi©ûýCýǯ¤t>ˆYcÃõ¿Ãqs’^.—æçã4®™ªEî ï ´÷ú0T¥ò>- @!bcómF ¤lФ®$Y46^š£já)dóa3"%I_9Ô;ïwêv»æÉâžP*ø^”NHP³Ù´Íˆ±`<½ ‰‡ @J 3ãñXÇÇÇV PcIÕÅã×ý)f¡@-zØü©Š„Ô“ºEMdîAºØü!¨NN©˜Ífj4Š¢Èæ.ÞFÚ†”Ëe]\\Xz2 i¯eй”H$ö_zÎáCeü|:>~“T2ûö?¤z½¾—eþQœƒúûèÑ#« –d©TÔÀ^¯g^SÈ'j&A"óƒ”þÕÕ•5/&­ICæÜv»µ ÕÙwÈd2öß긡Ê8ð,!þÓéTµZÍl ­VË‚7¾Ÿâ’J¥b…4øWyžTÀóÌ%ٳǢÀŸ1v6¬qÌCcÔSÖFÖ>Ö[ x ªØ&¦Ó©‚ÂûG7à°`ÀÕÁ÷#e%Ý@626¼RÒµB†‚‡ß!„æS>8ü=ž4I¤íŠF4¤›Â|P’,ÂÆ7ÆÉ étÚR¸Þ—EA›5æ{®‹E—Ÿ§j…”f® °À{¥’ká^F£ÑÞ©þuMc°|J‚$ƒªZú+zBéÓɨoÅbQ½^ÏÈ3ibï1ä2 3¨‡’Lu* ê÷ûFF$ àÿ!<½^Ͻb±hãƒÊv¨(¨´ž¨ªDEã2Ÿ}K”Qšz£l¡*“ŽÛív:::²ë‚ B& î¨\Òuõ÷;w¬p›ý1yn¼xùyÚ‡@Æñ™ñ¾ye ¢ÎÜã{˜'Ü7¶ªo©¦¦m }S©”5u†¤úJ|2(îôÞc-ñ€¼úb|†r|̹~¿oï9D—)Æ4í©úŒ T&“Q¿ßW¿ßW.—S§Ó±ñL&“º¸¸° ÐÛP _ÿú׫ßïk½¾nͳ†¨bAaM ÐàØ?æ1ÏúüüÜTMI{§æŒÇc-—KóË™åµû sŒÁøÄz½ÖÏÿüÏë™gžQ.—Óë^÷:ýÒ/ýÒÞâ¹Ûíô ¿ð Öüómo{›¾úÕ¯î}N¿ß×{ÞókRúž÷¼Çާú—¥D’Eä66_6)ºF£±×·‹M•ô‹;)"Ô üo¨1 &eãcñCA"eED2B%ÿßëõìú$™‚P,Õl6mã"&Ý4—•d$rLa)COhý‰(740^­VÖt– Ýo NGõzÝHÛz½ÖíÛ·•ËåŒD $øbÒ³s6T”Ž®‚ÀRáK ß®ƒ û‚ìÑ|› ùàSß($06~üP‚ÚË0ÏF£‘ÅÊïòß’ŒØŒÇcó¹±9ó™ÌË‹ ómÅãq›×¤û¶Û›£Ö²Ù¬¢(2EË"¾ŸÁÛhiB`ÃX¢îŸŸÛ3ßn·:99±–&÷ïß×p8ÔÑÑ‘NNNö|¡|-} \$ƒµÄWg{/Ç[$Yª•Þ|'''F„!———vÝødy‡ðìÑ—’5¡\.«Ýn› †5™LF/¼ð‚­;ÌqŠ-hµt||lEExfY(Â!0ñ¶2ðo IDAT¤À†µ)•JªV«Vð‘J¥,ÅKÀ3µÛ]Ÿ Üívm|ñàŒ1~Qíu:`ŽûñfÎéèèÈ~Þ{б)àäìc,ÒµÚNpMq›WÚ¾ñÑ~T¿ñ¿¡O}êSz饗ô±}LÿøÇõÉO~Ò~æcû˜>ñ‰OèSŸú”þüÏÿ\ÇÇÇúø½´Ù»ßýn}ùË_Ög?ûY}ö³ŸÕ—¿üe½ç=ïù_o¡áýN,F-6$*Ô8_²ãO¯ðçw²°AôH'J7)¯bøH7‘¼Vöâ‰_é,16tT@” ”:ß°YÒ^q &J×D%%÷ãO úçY@NhƒRâ•>ޤÂ\N —×Da žú—Mo£Wœúýþ^jÅŸ* ĪËx<®n·kê'­EPjPbÖëµ d˜ã· Ñ(i’¬Á¯W ¼o¢X.—­¯•Ô¨P¤â(T@Iáyrn4À‰BEuëh4Òb±Ðùù¹¥ð «Õª5yF=Æ&€¯µV«)Š"›ç¨Æ( (‡él6k~-È6ãY«ÕŒ A˜)Îà]Š¢È6÷R©dsÆ5 ØS C‘éMæ•ó¾:{6›©Ûíùâ{ŽŽìyC6™ >°A)džAòh³X,özúScxÇ$™BÏÁÚa"U.É r¹œÍ”ÝÇ ÌP3±vPPƒ¢m€b2‚ˆ­WU9{š÷ŽÂ8Þº'à%= aÄÆ@9}= Ħө...öªõyG°á¤Ói]^^Zï‘ï%p˜E ¯A¼óïT»ÝÖoþæoÚŸýÈüˆòù¼>ó™Ïh·ÛéôôT/¾ø¢>øÁJºN¥´Ûm}ô£Õûßÿ~½ôÒKzÃÞ /}éKúÎïüNIÒ—¾ô%½õ­oÕßþíßê¹çžû½Š@ðà<Þ\e…™…OÏáÃÇFz%„‡Å.þlè+Ò¸^E”¤7œÌõþ‡s½ó:ÑËÆ†Ã¡]Ê%‹&†nÒ þ c(u¨Yøs$í½@ð1¡‚éÓ6ƒâ pRMl줃IZb y5‰B ¯4‘æ,—ËÖzÅWL³©Ðj% Ÿ'ˆ°iðì$™oŒªN_Ä1ílZ6Fo~—n%šF“Ò/ æ±BQE]óäcµZ©V«AÇÛÅ5úÆÈô`ô¶RŸ\?ÏÄèýœ¤±%Y7$‚çËÜB…âÙòùŒm&“Ñh4²@ƒyÜl6-­Kû‚ Éd¢[·nYÚšùEÀÕn·5™LŒ¤ \ñ9(„XPàèáÇœ.•J:;;³çI¡5ì øIkˆÑóo)ýT«Õ’$ËD@x/..ìý¨ÕjF¢)¬J&“Öž†€†ö9L•JE›Íƪݟzê)Ë|¼üòË{>@Ö¯B¼£(²µ‘9OEøïÿþï‡"FP_ƒøîïþnýÁüþþïÿ^’ô×ý×úã?þcýÐý$éë_ÿºÎÏÏõŽw¼Ã~'“Éè{¾ç{ô'ò'’¤/~ñ‹ªT*Fþ$é-oy‹*•ŠýÌ?FcoC£ÝB*•²¾X,Àl lÊDàl:úh‘ª MÃ&ƦÇßáÑò]îI5JÒb~sR Å ÒM¥%›<•ÅÞÃÅÆFS.—-ŠFiòFzûèèÈ~ÿqž¤>&“‰È‹ª•ï™Æf‹§‹–"þô 6^†$k2ÌÏTÒSWwŠÇâÊåæކJ5RšÎºúÏN¯ç?j«tznÊS<W<&m6SõçYÝ»XØ)xÈ–Ë¥µ ¡B”>€(TCBØ鑿\gÃá …‚-ðÕjÕšB£Øåóy#{¨ ¾¢Ø§W1ä£èÑ«k‚’Ræ3 M¾Êå%•JÙ†ƒ·kçø5 ?$™úãÏýeÓÆ×åÛ¿@`¼§…’Œi# }Ç㱪ժ2™ŒxÇbù⪾ñ“¡º@D·Û­[æbü¨¾H:>-Iæ©Dö¤‹jMN‘à=ðÞWßKÏ ñôÕ×¼¤¡iƒO”û—ö‹+ 6fL4Ä… ­ÛíÚ ñxÜúØá‹ƒðz‚Î3à¿Qñµr<$«j÷^¸d2iñx\õzÝì$ù|~ô£6úàˆ@‚Ö9¤Us¹œgTÉB¡°×£“€Ð÷„ä>HEóÞñžàðŽòiD£÷óós«ˆ&ã€ÒX(”Ëåtqq¡~¿¯ívkE^4x† 3GyÞÇÇÇV L ‰ªˆU&à°àk¿÷{¿§ßþíßÖïþîïê…^З¿üe½øâ‹:==Õ{ßû^û9zà±êïÿ©ŸñøÈG>¢_üÅ_|ÕŸóóxN ‚TtBFPï$YÄÆ{u|T½X,¬¿$ÛxPmb±˜Þû_Ìõ“?0zÕu]ãºbôãïúO·ü»?¨è£ÿçµiž¶ÜŽŠ“J]ŸWÛl6-Ý„rI?2ÔLˆéLî•…Œ4›“$#¶"MZ‹M5›ÍÚùª´R¨ðùTBðhÁAŠ?Øt:µsqù>éÆ#…òƒZJBüPyEÚå…{Bu%]íÛ‹PAÍÉ$Œ~AZ– €ÑˆgœÊB?Eˆ)jÕ¹(R\/9sÎ>°ÁR@AU) 'ÏÜ÷$(Éçózê©§Ôl6õÅ/~Qý~ß¼bø7›¥>)àX?ÞT¦Z­¦G‰DÁ¥Ý $…3¾P¯Á``©`ž+ª$”*$â*M! 6”A‡Á``©DTÆÑhd'nðg<Ð~‡ç›Ëåt~~n)l*ÌQXyFårÙNõðê='ºÄb1 ~ñfò}ªx¥tÓ¢¥T*Yj½^¯Û-a!¨â:ŠÅ¢y!¾ñÓ?ýÓúÙŸýYýèþ¨$éo|£^~ùe}ä#Ñ{ßû^KºVùHiH×犲0Ò8ôq\]]½J9?÷s?§ŸüÉŸ´ÿ‡ºs玔 _$ð*AbˆZ}ÓdLàl 'P”:ˆæÿúÇý‡¿N(‹›j6MÅõÂéB×@üßêzé"§Ét¢B¾ ÍöÏI'tÅ”É\«’löéŠø36ül¤‰Yˆ9EÂ7“&݉_ÕÔŸi`ÔßîeÅô-ž!)LÔ¿I2Â…ê€ß µ‰^…ËåRÃá‘v»çµ\ƵZ´\~Eåò=KIùB£Ôy2©¥W}É !]ÆÁWãÿƒxùó…ý (R´Ô@éó'Àð¤¶1òSUN:snéÝèOWÀCȸ¾å-oÑÞð=zôH÷ïßßkc‚½ ßï«Õj™"ËûDú W \á1å;QÖI—“®e| …‚Êå²Í”Gæ„ΟWíƒH3ªä—³€}ÕzE{ý'}»"þíƒ@Iö;óùÜÎÚ%ÀC½ƒœEQdÄÐ[ ‰„..., ìt:VÅËq€<‚>‹Âÿû¢ÞU¬ö(Š^µžCZ| C½æiIzæ™gt||¬Ïþózó›ß,ézQûÃ?üC}ô£•$½õ­oUEú³?û3}Çw|‡$éOÿôOE‘¾ë»¾ëŸü^ßôÕƒb Zär9S¿’ɤ©lh˜Ý!Š(¥Rɼ;DÁlÚTMz• cuw›ÖYÿZñ::Êþ£?íz“›L¯IèWÏ3úÓ¿_(—㈭Œ]Ëõ†²1…‚Í”ïë‡êñC™ð–}“W¾c±X˜™Ï O‹ÑR‚Í¿"i¨B¡°×¤x»Ýš:…AŸM"‹™¢ÇQpS è’ì7T 6øN ˆ¢”&“£(ú>-—ßòªçyÙQ£ñ¨Ùü_”ÉÈRߤF!m´¾‘dç—B`y–TÂâ‘J&“j4:;;S­VÛKñ’òb3ô¾;Šh|º–Ÿ! Æ“%Ý(7¤ÀI%n·[óu±±òì PU?ÿùÏë _ø‚µ™¡bËFïIjÖ|>·Ô¦?²"ÃÉɉ’ɤ °èÁÇ<­V«æ¬T*ú¾ïû>ív;ýÑý‘.//- +‹ºÿþžj™Ífu÷î]=zôh¯)9^TŸ€`S MÚ–ì …(½^O…BA¥RIÍfÓ ·¼*™H$ŒàRàÃ÷ø é€ÃE €¯Aüðÿ°>ô¡éîÝ»zá…ôWõWúÄ'>¡ÿñ—tÊyñÅõáXÏ>û¬ž}öY}øÃV>Ÿ×»ßýnIÒóÏ?¯üÁÔOüÄOèÓŸþ´$é}ï{ŸÞùÎwþ³*€=P¦X¤¼?åói½YÙŸ €‚…’ ÉÒ¤-›0$Šh–¢Èã5iÚIâtŽŒùù¤¼´¯P žI²Ú÷ãq1¤–Me¯¾4R¥ëõÚ*ÿ|sÜ(ŠlƒÆG&ÉT‘d2iÊ‘t³És¼ ¬o~ͽ¡$±aøÇgˆ' /"Jäõw¥4ÿ¸>ü€¤¸ …ÿKGGÿN¥ÒWÏÿÑõ¼ÖëÖÕÕ§Áà¿V»ý?ª^ÿKU*ó?Ò'M’)‚ÞJž-Š ›þGf³i͈!R`|]Œj.Ϥßï›jœN§vZs¥T*©Óé¨R©ì5:†d ÀÐÓ¸oÆr„²J•èh4RµZÕå奥°!B¨œ´$a>Öëuóçá“õ„b:êÖ­[FP¸¾Z­¦r¹l>0Hæåå¥)J’¬x€w²Ñhh0©†¬ø<Ì«L&c)Îùüú¸2Þ=ük¤¬!Fb‚=Z¡Üq|¡ïá—ËåLm#å yæhB”DHÔ:¿yÅ—õ„ñ‡Š¢ÈÞå‡j½^ùƒlò^L¡x«H&°ÀëÇ; ñît:¶Žû÷ãñØ‚%ìÌmRŸYñÁQ¹\ÞkAE`pØUÀ¯A|ò“ŸÔ»Þõ.}àÐóÏ?¯Ÿú©ŸÒûßÿ~ýò/ÿ²ýÌÏüÌÏèÅ_Ô>ð}û·»>|¨Ï}îsÖgM’~çw~Go|ãõŽw¼CïxÇ;ô¦7½IŸùÌgþÅ×Ã&€zBÚÂ{ÙØtùs*uýÏ V¡ÊI7䂆)e€"IéÑÒâñ~l´øžüõ¼ùÍoÖ3ϼˆx§:Ž5Ž–d›/cÌŸqÖ/^=F}æ«T*éêêÊÈób»ÝÚQmlê:!ƒ™Ÿ¤³yv¾×`"‘P»Ý¶kßívFZ!ƒ¤@}*œ¢ Þ/‚¡««+ ^Pº!³Ýn׈óÀ÷ô#¥J…2}±O`à³PÕ9‚yÇ­™öb±°Â ߦ…95T«ÕŒÈ3¦¬+¨Æ*á1åtŸjÇ“‰¯0“ÉØø¡"‹Eu:;¥ƒuƒ  X,Z0C1 )x„ÉdbE@4gÞùÌÄ`0ÐéééµÇù}’¼‹ø%)[¯¯¯û“`+¾Á` OúÓ¡à#(€O 6-_xH$,=…¡žé+RþAíb3¤¤µÇ+‚µZÍš±Ò2ˆ–’lÓ#"ö‹+¿ƒŠDäî7qI¯Š¬Q”Haó{{ÙÀh4Ò½{÷ÔétLÕ`gcà^¹ÖÛ·o[ê Ëû+Q «Õª¥ÇQ%Y ›©#_!ŒsÂ>Õƒ¿­x|¡çž{¯ …¿1c9*ªýÙÈS)é™g~V¹Üÿ­³³IºN¹ß»wO/½ô’$ퟅÒu||¬jµ*ézÓë÷û{Řå!W´À Jv³ÙXЀ*KËZ¹@Qdy~ž@æ!RÞŸ7™LöTbÆ% U#ÌHrݾÀU‰‚æãQ©T,E×l6Ís×n·íwŽŽÌæÀï5 +"uˆµÅ…›ñðd›ìJ:ö\.§Û·o[Å8)ïjµjµ£ÑÈš7K²ŸƒáýƒS°DÊ’ÀŒÀ‚1©V«Ö8Z’ Î÷xå‘#Û˜CH$÷E‘†Ã¡½ .ž=mpèûÈÚF›yü²ü>ŒçËãž $™e†ûókts:/”¢Bž±ãzéÉù£%ÁJµZµˆ±8l`Àƒv,޾­ÿ°ãÕ¢(AÒž3¾;6fR\?6p_%̆Æïæóy¥Skû»ÕjiéÞããcKµ°¡ñû(x‚¸~úòsÒõˆêSþ?©6|=^¡áß(uëõÍi*Tj“:¥r‘J_ÔTCˆÞ¥Z­f$rîe‹ë›Ï¥G~UÒVO=õßk»½ñ7ñœÛÕje^,_вÝNu|ü úÚ×þwõûÿ­ß²†Õà¹J&“¦dÒJÕ„ààòòÒŠ/æó¹úý¾UhR¡<4 ŒÀ÷z=«¼†üÐoçúx€@µ(éÅív«XšVxBñgúós*ïëõºÒé´ƒ)>lÊJ&¯û@žá x¢}EP>H¡¨²BPE@&ݤr¥ëª[?Ÿñ”qmTJsD#Ÿ·ÝnM d.2oèïÈ5=xð@ÕjUÕjÕ‚œ?îuLNª¡=çP£„{Ïp©TÒ /¼ l6«¿üË¿T·Ûµt1½ú˜_WWWÖóÎò¤Ói]]]™jï×Èï4s™“F($"XX.—{$BÕï÷í}›L&j·ÛHÐî[Äp:s ÁEkÒ¼Ìgßn‡÷“–M£ÑÈš=ã§ÅbFöÜA øWJ‹DPºñí‘ròÕ¤^HÉy2bA$ÝÄBF:‘…žt j,SgšÒÇþcN¯t×ö=øÊPâñ¸õãcƒÀ£µZ­lCáïØÌf³™¥šØ0Ù@ðATIÑ`‡0rí¾_¡P0B•ÍfMáCá!Ee¢t½Ñ“ÚÅðùd¾?ÒÓñxÜ*~Ù¼;_ÒrùœNO? tºgãQ.—mC$uŒÒ‹é_’ù¹êõGªÕ~OïS>lßÉÆ ñ¤Dºi2Nš}2™X:O%Mq)6‚@2´ë€\ã)],F>!¤ñ©Ü„7 Õj5SQ!¢Œ5›9D€ï¥Ú˜ùÏuѦ‚‹ÏU§ÑhðÞ?o/Èårö÷TÆr: *$‹ùDÕZ’ þPƒ_””-e(W¤¦ŽŽÌwÉæ>!äR¼š´š9>>¶¹‰å V«áeür¹œz½žž{î¹ÿ‡½w–ýª¯üÖé×é÷»û<î½Ò½ ,ƒx Hl0 ¯˜)¨)ã3”+qñ°I\ñ©L;ñ€gl“*»œq2Ø$ÀؓČmdM2زd$’ +!¡ûй§ßïîsú™?ZŸoûâ™ \§rzW©$Ý{N÷ï·û·÷Úë»ÖÚ:wŢJ¥’¨“§ˆƒ÷ààÀ.žÓt:50Ë‚qJ)ºÛíÚô§ØÐÏŒÆ8ýœ0ÇxÒh4Öbnf³™Eððî¢IL¥RfœS æHÀF£¡V«e ©Ãgĉ6èj[­–bÄÍ;ƒ¹¯•Ý´“Ù6pÓ®¹ñÁ‚…†èj²$[\˜€0øR%»Z@¥;Ê,h”Ý(ÿ«@v™$U:ý÷÷í¨;NXZ?,ž$û]X@%&€,@ ×.à°ÁBdz8rËŸÃÁB±0-ãV–'"À&H+ÝR¯×S½^·£¨|– q/”aû(7J«“ X x>œ3™¼^ýþ;´³óa%“ç X°ÀÑÿ[[[¦¡óß]¯×M_¸Œ2ù—šÏãªVÀÊX’LgÆâÃç²øs'ŒgÇ^턆ÕdœZ?u‡ü€ó”ïÈÎ~Ã!iíŒäÙl¦B¡`aÈh¾¤¥–¿k·ÛF`)eÂrbÎNÞLE€PÊÙ8Eãñ¸NŸ>m,:& ÜŸd¢uãÚ†9óa§’ɤ±ŸŒ}œÚl”$öœÜü< ,¥UÀ,LV,3杻4 Ûø1æz½žÎœ9£Ë—/ëòåËzòÉ'õÔSOó ƒ •Ëå´»»kºcJóÜ ²>ó㎒8ñ1è30»ÛÛÛf2áüsÞQI¦)fÃÂø>>>ÖéÓ§íT6®FÃ$l²€ÖL&³¶‰ …–±H”Â9)ˆwÉ›=®ñÎ;ïÔûßÿ~Ó«nà¦I¸iàdoÄð1-,üyý å Ikz4´qü=e |.€‡ÅÌkõF£‘•p¼ùA6  ;gÏ~Hq’só•N§×tf¸1apòù¼õÓ`0P¯×³Ý>FX"#&úQ9¢mú4‘H¨Z­ˆˆ ¸^ÊŠ° ÝnWóyXW®üc%(“ùCcfð€VYØéŸH$¢B¡`Á¸ÙlOÉä—Ôl¾Î€ FŽd2©p8¬t:mz0¨ÙlÚÂÈÂã»êùbœ½ó¹’lq‡Ýò®hú‹k»zLÃS2x¦ˆ¤!_w9Ú8J½0¾\%E€,€•÷–Ë;Ÿ3™Œúý¾Z­–ºÝ®i2ɬH²ë¥ìÅ;éÝãNÒ·ûŠæÌgùè ÀÏ#”–‹ ‡8œ~…Ùë÷Rãñ)e2?¯££‘•VYì<ƒ À€­@“†‘òÛÒ ñõz/×|YÛpýˆÿ+,x†,\<ÌlÐQ7½a IDAT:‘7×h4ÖtV|숴°C„i|¨9› ÏC©®P(ØÏÁ£)Ä”D 3÷Ãø ¬^Ö;•JÙI8Œ༉6™ ßáp¨B¡`%k@ï¦ÏÐÿ1Þx—`—\ ƒûDöHãÝ%–Ż潶‚$cãýfêððP­VKÓéÔØ2ÜÂ8€ùlØ[î‡üB¿±$Z‰÷“Z>Ÿ7F ýÊfSNx7¹—­­-ˇdn _ù„³SÒÆÌæŽÒ8À»Ýnk>_žEM%ó–—š YD#èó’lÃAF#]¸pAò'bÒŸ°i'·mà¦]sãàùÙlfš&LŽcÑg!çÔ‹~¿o“0ÀF ¦ ưFöW§ÓQµZ5­eCŽpbeÁç³€¾‹ÅŒ7ì®Jt‚¸i …‚1q€_²ú8©Â»F/ý~ÍÁʵÍ ­ÜÁ”ƒ=€òúB$XúIÒ &éùÅn[õú{”Jý+Åãß2æË]SfE#GI‘ïñà€¿|®_ÓbQ¿¿·Æü¢ÕœÏçv2 ¥ºb±h1”›¹&6ĉPŠãì^ 8kaÛØ4Ð7°¯‹ÅÂÆßÕñ69 á¤J„°ÍívÛXhØ5ú€`b®™qOŸÅãqíîîêôéÓ’–:HJü3Îq…&"à èĈ²X,túôi•J%e³YsÚ …BÁúvŒñè3!Ѱa^‚¹‚ †}Ç\°½½­\.§L&£d2i'‡ÀŽÂ¾Ãè£G}öÙg×bj8g¬Â†Çb1‹Å5Mâáá¡vww P"™¹hkµZŠÅbf>!'QZ²‘¹\ÎÌSü^«Õ2ÖÓGëIPyûí·ëío»b±˜ªÕª…’ópG$í«"lŒK˜ŸÐ7û¼R€¶$Ž>ß8©jµªóçÏЉfÓNvÛÀM»æÆâN ®/Q£¬Dž;VÊLLìÌ1°ÐcÁì@DL:6ñ3 É—†ˆŸÀ4¸dòDÁfÐÔ˜Ø-0` `p|DÉÎÎŽ±\#åf¿0ÃôP~&x¸ßï[™@Ësý\ €²×ë)‰˜6‰Ï„ú¨Î¥IänÍçY Ÿ´r®7 À(QJÂ<`ív»&šÃzd³W$I³Ù’d‹ $º?ÀL À ûã˶…BÁ2ã|ÄŠ$ûYïÞäY$ˆð€¡#^# l ã›,8â{Æ`„¾€MÂ4M?æû@ “…~ËgYÒÇü<šYâX,¦v»mú@0™LÔjµlSó}C_c4ð¦Þ?\»”šé'€L ÏÉË:€iõˆ'á^n1€ïÿh4R³Ù´±×l6í=h·Û”<Û¾»»kωea$ÍfÓdè4a;aYÙDx76àS}ÈõF£Qèþûï·G˜c/Äe2ë;[Cþ%cÃì.ñ7\'±[Ì30¤TU˜ý‘„›àMÛ¨@7íšÇqQ’dg€<äp¡ v”Ôöö¶ °™x)±Æb1Ûé½Á1Y°oJ>V‰¬:€)@0 èÀ``‚„ yca$ λö`)Y|`ùX$Ê‹>ÓŒrl€ƒkƒ•äžX8YÄ0¿x6R/ÇO™·Óy—R©û^–X+£á¤$ŽÏ⻛ͦvwwÕív•Íf­O÷“I]Á`KýþåóÁµàn:œá8\9›˜Ï“´Æî»Áð‘dzƒ¨\.Û3A³ …ÃJÂÊI²|7¾q À•Vùplf0ÈpÿívÛÃa÷$™„A’ýŽº”%(46&°sô·$LÍfS¥Ri-}ggÇžÛþþ¾n¹å- ýÁüz½žX¾ÿððPÅbÑ´´°Í>3‹Yà³gɶœL&ª×ë&ç Ül6Mg)ÉL9ä.òçl:a!U.—¡õ—ùÍkŽ“‡‡‡v¤óŒ-6;Œ3ä#ÈgJ«ØâlF£‘®\Yn²˜_0yPF·Ë5ÁF"Ù´“Ý6 à¦]scq¢üÀŸa„ ”Æ‚ðc!ØÀ$‰5]À6B’1|€šR©d ,¢_dì„aÈ7 ú`$ù~@öŠ?é„]9±”xacòù¼Âá°:ŽNŸ>m±&Lô^øMŸÀ>xÀ€xæË»^—(É´öÙ߯ããïS2ùI»/~>N+[T šE4x°@€?žÕŠIk),ؘ€äyÀRU*Ó¾´ ›æÝá>³‘E»rõ‡¦M’K†`‡ýø£TIt ú+²‰N©×ë>Ù€àž…‘„ŽÇãfXdÀ”èT*eyŽŒun´zhÏ8Jø6¼CÜ+ã‚M œÍ ,F!!Q'’Œ……ƒõ%†ïÅ™ ãã‡ôÂ/˜ØDñâe¬°£¼ é3(yG£Q;ïÙÑÐE Íx¢o¸XXŒ?”†ùNúz:Zõ-3ÕJÉä“V«Õ5÷/ŸI?Ìçs{WÙ8z#1/ÙlÖXX®ùŒf³©@`ãHÇ … PoÚÉm¸i×Ü| D’…ÃN±{w.æ vJ•Òj±öa®L®”~½‹–̃,JÏ€%ie*áÀyo6ñ¥OŸÜøƒ•dÑe1ôeŸ`py =BöR©dYqh<³ÙL™LÆL3”¯ü¿ß·ƒä™ô¹ O¸X<Ÿ+¨YÆÙ¼F@_ÅâÃÖ—ÙlÖL”õ’ÌùŒ;v·¥wà.µc M§«skyÞDøö÷÷×\³]>—2»wšG"e³Yåóy;——þX,ªV«óB,Èl63@Æ¢L¤%aØWÆŒ ¦˜ËR©´Æ.r" …Ólè+ú Ì6 ‘XÆ2›ܳ8¬%£ ÌØDÓztt¤v»mf IVþð̹]¸ó±:>JÆkLyߢѨQ€éY¹·F£¡‹/šg¸ñ¦o9¥t%‘HX©—r)Ì-¬,˜R*óß\ùêÁÉÞ‰ ›–ÍfmØ•–›EÎé'Î=ÆI<T©Tì;)9#@g3Íi2­VKÍfÓæò}Ùž@NƒaƒäÏFGêÀ5"OÙ´“Ý6goÚwÝüYÀ°$°oì^™ð¼æÉdzŒÇão+)I2MŒg>ް†ˆîaê¤åQcLÆ,"ålâóÐþqžq`áÀõÚ+~Ÿ‰–ìÌ™3¦kŒF£j6›ªÕjVŽ¢4N^\0T½^_Ó)J²ieâdÚDØ:ØW²ÓØå£á¢<Žî pL&õÌ3ŸP ÐÒþþûÖJX°{>n‡²$îf_ÒFÚÛÛS§Ó1à pxê©ÿMÑè_éºë~ÕÊÎoV«ÕÖÜËžåãó«Õªé¤`RaͦÓå±o0¡„ss¾TÍñqœcëãq¥RIõzÝN\ ¤&ÉÀ7, ®×ë©\.¯…Ó„0SÖç^Ñ‚6 î>†æàà@ûûûæš…B–×ÈõÍf3c×Éæã}ëõzJ§Ó¶!ó ¿×îÕj5+£Ù›†¶ò0rIk À+¹V«YÔÀ †›f à´µµe Ñks)ÍûX(€ã…y# åOÊã‹Å¢X`þa¬ÙdÇc;{¶÷M'²\Äô¥?‡g ÉÆ#×ÇýƒA“LP½@›Ëýmmm©Z­®…r³òÇ1æóy;åÇáÓ0‹Ì€QÆèÖÖ–~í×~msð n à¦]sCÃGÉÍ—d`:X ˜}&™g°(ÏQªõL>¥Z&9Dõ°C€3„Ð|““&z9)Ø(>GZÆx<¾6Ás_,Zçâ¤D¯CI¬Ó騂€†0‹­…ºúP^\.o,àga_Y¼`|9Íg¯þ†Ã…F£ÛT*ýs»ÿœ`dÑaQòö‹€r$îoŸg7› nÙ[*•,&F†çÃCù-‹™†Œ²¦?"lGI6öÐRÞ"šc¬4¥7´f£ÑÈØ2î'2ßÝn·Í͉À3T˜(Á\q5±XLårÙÜ©”—ív[©TJårÙ@ šBÆÏC’-rúüø…Bö÷@ l?'ÉÞÀ Ó ¬eS6b±XL‰Dœ?†6ïâ9 S„%d¼6›Mííí™¶æƒ%zK˜zIù7L)™ä%ú@èÙl¦N§³å€nµZkŽr€”×cúTÞG«¯ð܈¬óâ uô‡^¶ÀgÀвáóÀó¦›nÒþþ¾î»ï¾59›N?'øPõM;¹m36íš“# ªß᳘cBðá¨L¤Ì‹ÅÚy»~q¢l#¢ …,’ƒ²³Ï„c’¤ìƒ†îI’-ö¾¬ŠV–à(ãwO|÷àðîYL&qÀ l%¶Éd¢l6«n·k‹l6›]3+ÀJ±0#Ç=Ñ÷0,ÉäßÖbQ<þU’èûX”Ð\Q¦$tXÒZÿÆãqZ¤Ï"‹k:ÝS:½,RRpÑ(ÏüùNØÚn·«½½½5'çd21¦‰ç!ÉÀã Ìã&ã‘/ËúÓ–q[‰DSù|HR_©Ô–¢Ñ€ŽŽ*cšÏ‡æ†Ãáó ä‘õ£´©K½hW¡ÐT¡ÐèyFpK[[3Ç=e³u»5•J%ÇËóŒww3ÚÚºü|ØóŠ=F£ŠÅFŠF žS4:W6›Óx|¬Hd¹ xž¨zÞ<±{j4ŠÇ3 Ž´µµ|îÅ¢™D`i„Š¨Ù h0˜Ú 5ÉdÒ€2AÙ€A6=Œc€/%K60tù|Þ€Ðd2Ñþþ¾eå±k4ŠÎ¸ôÂ8NŸ{î9c]ÑýT(ì”q"s7ñ®!/aî ïqooo­2pttdÌìãr£5´{EîÁfÔ™"‘ˆúý¾NŸ>­ããcu»]s9£”dï'ôÓéTO>ù¤.]ºd²=³Îûé³7íä¶ Ü´kn”ÉÕ’Vº:4*^›…ÀÝç°1QK2…¾ FìèèÈÎ3õâhô€IVÖâÜMâX´|n`+—ËIZ1ˆÜå0XFvø©TÊtWãñX§N2³ ‚õd2©+W®ƒ>ÊRX„šÍæšvÒ å7Êê’ÖÊã0Ë,:8—ŒCêùïÿ–}o$ÑsÏ=g,? Êçñwþ³‹Å¢1d+&eOóyLÇÇO‰pŒÎ V¦Î³•èà¼ËÒo4$™þoww×@¹$+™ “Pžæþ`¸,ì¡Ð2‡ïµ¯ý’þÑ?zâÿé×èÿ“í¡‡^§/~ñ?±ÜÊZŽë”™šˆQ‚f,ŒF#u»I0£€Jß0ÊÀÙl¦7¼á+zà—*X™]b«Õ2ó“ÿþ$®ƒkƒ—d¿GéØ¿ FC¥RÉ\ò4¢éô-ÕjUgΜ±ÜÅý~-4¦~ooÏ´z|¯7}ñœ¤èQg³™È3¸Ó騿 ã–—|´Z-e³YªP(X|{{Û˜FÞ}ØHú‡²ó|>·$­i„‘’´³³£Á` R©¤N§c`Z’`¯ýƒ Ý´“Û6pÓ®¹…B¡µbœ‰¸\™¼Y™ÄÉK&“6Ñyg €„cѳLpívÛ>SÒš¾ƒ‰w̱hpÄ¬àæ ]™’²Ù¬n¼ñFÝpà zík_«^¯§Ùl¦óçÏëÊ•+Oðêì¿B¡`àN’-X”U}É7Ú– pFyŠr+çú‡C¹Ïfa…Bã5@&imñ@ü±Ð°€øH¯£ÿûý;”L~Cñø–|¯‹‚1‘dÀ$ cÉwÁ^øRƒAíììØQ`ÅbqmP6,bÄI¥Rfd`좗Cš“ BGº,5öô¢ý…xà …VÆÆï+Y|8{}v'ú:Çãc}ØD —õåwrë`ÃaC¡ŠÅ¢= ž+4|¡âñ¸å9bðZ,º|ù²vvvÌ´Á¦ Ÿ¨ßgŒs~‡ñ¹½½­½½=+óî¶Ûm]wÝuVæfSœJ¥¬‹Œq$/Ò2ŽæððÐX;ž:LJÓ\N¸‚‡9ˆÏÍfÚÙÙYËKÜ´“Û6pÓþFZ&“1«$‹ ðŒŒ?14Çh% ;)@âŠ>ŒÏÌ ÛÍRþðæ Êoˆ¿Y¨Y q ÂæPžb¡"¦ж ‹)ëºë®ÓÝwß­›o¾YÒR|ÿŠW¼Â@„´U»»»jµZ¶¼[™Ÿ•äØ'Ê߀“ñxl@ Éïã–öá΀èf³©t:­ííz=X#sÌG¬H2=\4U½^·gMôÏØ—«—ó±Úí—)›ý„¹£awpI{}#ŒÙ|>W¥R±Òj»ÝV>Ÿ_ æ¾r¹œ± ž}âúØ$ø(ù|nG²¡áb<ù`qò6$’LdÏ|¥RI…BAµZÍbSиQ†|â¬F+ Û ˜ã¹Ñ·ÚF&f­V³Ò¾ÌÒ*ø`ËÞl6Í@„[™SMn¿ýÕdÕ×¾öƒV&FÁó†}¬×ë;KL?bÃÂæëä]†Å¤¯èï`0h§iøÌB>CêA%zܾ8’ûý¾öööŒÎd2Ä‘§0_p-ÇÇÇJ§Óª×ë¦_¦)ÅòܸÏ@  J¥bã ËØb®9<<´yMs"‘P½^_“žðïT*e§…B!s•ƒA]¼xÑŽoD׌„S\‘`fÙ´“Ý6AЛv͉- ¬L»e XAJR&)"†Ã¡-`>­ß øù|X+JL°&”âXØY|¸â7`¨f,ª”²ùB£¹N¯…šN§êt:ÈëãÔF£±vÒ å.˜ôx^ÇuøcéˆÙ@7«‰áh^,æ’¶ì÷qÿ²@ÓøLÊaþH<îëØÕëuu:/Õl–R6{Ÿ$™Q1=g»²(ÂèM§Såóy-ù|^•JÅ 5€)À%n]p4[€vÊø°¼„lS‚–d@ ³ÍÊ!¾¥ù|¦z½¾&Ú/‹*•J¦¿‹D"È  ¸är9c¼{½ži½²Ù¬±q”½‹™q?Ÿ/O8aÓ«Hy—1Á¹ÓW›‹øün·«v»m› ¾«Ýn?+ºõÖ/ê¯þê´X¬À,ï @tN4¡,Ž®3‘H¬¹ËqÀòNú’9‡‘ ­&€iÌ&ï4Lã‚wœÒ1€‡¾L¥R6n*•Šä¼Ïèò0’øYØ´ ÇôÀ–qÀ|h¤DL_Öj5¿°h3„²ûëãs`,ž0Èív{-蛹‚Pëe@û–mJ7íä¶ ¸i×ÜØaÃÐP¾b*­Bž™,½=•JY9—Ö³6°2Lž4 =ìI<×h42W±?Ká¸g7>,—‰Ò;•9¡Â*p4ÃæPzÏç:w…¾ð…/ph·ÛÆVÖëu FsBcäóYx(ûbXðåX& 3ÄÙívŸ/Ž4Ÿ§M—Ôív­lîA Ïv°Âó‡¹Å üä“OÑèSJ§¿©Ù,iì+ŒW6›µE”2¶g1%©T*™ðÝÿÎçs+™ŽF# ƒµÜ9ÌÞI¦‹>}ÂbêÍDè²¼ûFˆ²3ÇÀy‰á¾”A‘:x7³$;: ícw( ,ÍÁ``e×ñx¬F£a¥tÆ ïï9…NçÛX7NžÀ˜ƒÎm4é%/ù¼Æã¨ÎŸÿaM&3Üf޵··§~¿¯Á``ïU:¶qAÈ´×®f³Y³^ß&É~€Éxæý´±ù!èÝ;â‘9är9+O3V|U¹h:]†‡ÂF69cŸSF¢Ñ¨­ïkµšs ŒáR©¤P(¤J¥¢^¯§½½=»Ï`0h&3ÊØ°v”uýõ×k8êòåË μç7Ô>žŠw2«R©@fÎ vòȦì¶a7íš§0qÁüÁ(azüØõ·Z-Û½SÎÁñ‡¦ } 2`MÒš+X’1€8JXL”S/šg‡Á TãË«8ü$ÙdËõær93†|å+_ÑSO=¥Ïþó:88ÐÑÑ‘-lý~_/^T·Û]+™Qîõ ¤¤5F‚ïÍfv¼`摲'ÇPáPrݑȷ4™ìkk+fÀñjfpÁâHÌ 8 e·Ûµrù’*¨Ûý!;÷§ ‡WGjÑ_Þ¥MÿF#‹E%“I`W®\±±Ð…i¢¬ hæ¹bâø7¾+›!IZfÁ=ÁæHZÓ~-ûdb`ÖÖïj‡%Ï©×Òh4ì3g³™šÍ¦õ¯$“2¡PÈò‰J$VV‡y¤ kHdyÏ™§|~ nøwúò—_«á0ðmæ6·Ür‹NŸ>mf 4t€KX]ô~äHJ2·.À…<¿Z­¶&%€Q Ò æ÷aò<ž²ò; Cg<¡¡«T*ÆŽO§SÕëu…B!™€ºB¡ —½ìezÙË^¦ÝÝ]E"{†nV°ì“ÉÄdþ?¿”ËeÓF{CãàÒ¥K&Í@÷‹þ“0mÖV«eF&Ÿ¾ÀfðçµÍ›v²ÛnÚ57vÇìJYXÈDàƒ(ƒuÁaçKy€7œ«¾Ô#É|v¼¥RÉÄíB¾áK®WƒA¯L&“v,I&ìæH¨V«¥'žxBÕjU.\Ð7¿ùM ‡CU«U[¬aS¦Ó©Êå²1Þe ãàcA0,‚L콉dÁ9 [ûI?ÑÀ“’‚êvwlQ̰ Òô9‹èh4ZÓ\°X*•¿§@`¤Dâߘ^‘ò}»Ý6ÀÉ¢›L& |T=»3Ÿñ=” ½«ºÛíj6[žY;q‚b!õåa~ŽjôZè¹B¡° $ô ‹7 Óc‡ñƒ³›x>«Ýn[ù•Ò-Ÿ‡Ë{eÜ™­1Á”ç)õ& +½2†<Ó;Ûjµ,\Zž–2õ’—ü©&“˜¾úÕ¿cL}ŵ‹E]¸pÁîW¯/K¢%ÿÒ“p™sÝívÛú\’1Ü=ò)a¸è»N§c÷‡­/ÐüÆb1cÞ;ŽÝóÒÝ5&œy†±†sF1+ëìÙ³ºþúëuêÔ)•J%M§S‹Ec¥•„€¾‡mæºü»Ã†u<«ßï¯9ø1nÀÜú1†1ŽŸ%™ ›[6 è/ rßÞÞ¶²ü¦¼i›ð¦]sc§ÎDÇ¢ ãÇî-¤5F‡ =‹–ÊK2ÅBÃÎÖgÏ$™â IDATaðg²òû°°n’lBÇ*‹ æÆ@@}LŽþ†’Úññ±´X,ôì³ÏZY‹Òú+_2ög„0mHËóÑ…B!Õëõ5£ƒ?™R: 6'1lM>_ÑÅ‹Òpø"e2O( ªÓéøb!xB.—3=% Lc·›W³ùT.ÿ®æóÎZü¬[ P½^7"€†}åzþMŽ! v§Ó±ûg±D À³€™óc ¶Ö¶R©¨T*­•Üõ/­“‹eÐp½^·gäY`ÆcÄkõúý¾Es|ÐÎyfN’é9wwwÕn·•Ëå¬_| ›6à¯R©˜! ÍÎæd2i› ïÏçóŠFkºí¶uÿýoÐxQ 0·\Eí‚\s…$cYŽŽtùòå5}¯?O¸ÛíÚFó€i2Yž)ͻǃçê™Dô¼™6ŸÏÍu= ”Ïç <ÑÈ9dNòÒÆ0ú_À~³ÙÔáá¡ÎŸ?¯Ñh¤o|ãöN06C¡•Ü1Üð,Ãá°r¹œ…Y§R)jÍfÓr3™Œ†±–È/üÆàÍø.‹6&½ã]!ï É>ö‡*˦ܶ€›vÍ @FYÇç¨yS‡´:$ÌO’èØ|¸°Ïcó;b"C"‘ˆ J²#ØXÄ%YiŽó_Yä)í²ÜétL„€…á”e2¸,X쨹ßf³i1!&O @…E²# :; © á;¸/ŽP#Ü•þóy“ÉÄž%©Ý~FÛÛi4zr¹Ï‰F£ªT*Fv"¬™$c`¦Ó©JþKðAƒ•Ëÿ£1>‚ƒ3vù<´Ž"‘Õùµ˜Püüÿ`00¶Ã_‹ÏD#ŠŽ”>‡ A/â9qäÙrŒÍAÌâLù‘0cÙp8¬t:m§ãH2 %NÆ»"báÆ¹‹sw`À³aÜQάÕjVúã÷jô1¹‚ƒÁÀ˜Ûd2©ÛnûœÆã¨¾üåWéèh•×Çi”Éy·)gb¶àû`uÙt|x·Ÿ7ƒo˜"“# !Ù­VËô¦ÑhT;;;σ„†nºéÏõµ¯½QƒÁ*ìy<¯Éx0p8n†1‰…BAÉdÒ\ö’Œõâåóy+ÕzÙ‡;¢¢À;T¯×Mˆæ. êÂ… 6Þ‹…òù¼óÌJ¥’"ä±XÌ~†ŸC¦„öåút:­R©d¥|N!ÀÚ›Ê\œ6B_bR‚ÅXóžòg\›$´±”Ç}ÌúÇÉFCGGËt˜[`.7íd·ÍØ´knD;H+Me'iöêõSü` @5™LÔh4ì´U,Hì’=ãç5yÒJÇþ VA’t},†>ƒ-`¿ J«|Ó­ÛíªV«­E6p]ìîY %YÌÚ34^­VËÀ3nd¿€ò9Q<Û (ñoL ˾ø7Z,ÂjµÞiÌL¹\6÷"±‹ÅÂôq0i°e°Œ£Ñ)}ë[ÿÒé¿T*õGÖw€sØ t{€+Áåé$Gö Ñ@¡õbœÑÿdX´y†€BÌ LFgÏb° Æ£\.Û³“d±œ/)s]/~ñÿ®ñx™ûçC† °ÝxvŒ5Ø\ž‘7yÔj5cI‰báïxK¥’$;ïe;;;„Éî“dæÊÛô3}öÔSO™F¶Ýn{ËuÑ¿Œ%¯Óä4"´»l08›0ÏfC›—¿ø=ó¹›°Ä~,ò^ûó cÆW,`tÙ år93â$ {æ~ ³áØ´“Ý6pÓ®¹ya>e1„Û0>‘žÅØÿ.Ž´Ph•gçšòÎBÄÖ8혀ýŽ–Ý»’fá˜N§&LGÿàðåNvÞ¸nÑ“XÌ‚BÄ‹2 }<7÷/·ù•–€9ŸÏ›ÓÏâû}vßÑÑ‘1,¾t0ÂõG©ÐpûcXÐL¦§lö_«^ÿÏ^oÙx<_šGoÉÂ_,íh¯`0«'žø¨B¡¶n¹å¿Õññꔌ ÄÀðL±>f†Ü<î Ö’z.—3‡p·ÛµûcŒÀR'^‡~E¯‰iðÉØóZU¿iðq%ÕjÕežÍÉ étÚ<ÊÇh¾Z­–NŸ>múÕb±¨l6k@‹É;Ħ„qÀx…%(Óp\Sb<Äù®%sTÑÍ7ÿ¥}ôGt|¼Š ‚)`Ä<‹Œ ›ÍšîÎënÉqdãÄ&ƒç‰à ójgggmóä™{î—M 0úê3gÎhkkËÜÊh!y‡Èáócn6›éððЀjµZ5ð‰¼Ù3v¡PHÙlVÕju £‰Ìçóöù°À|7%nœÃèƒù|Þ6”lœq€I/{`£håy³ÑbŒlÚÉn¸i×ÜX¨˜øY¼c6¨\.¯é´|Ãü–Ðÿž7&0QS^ºÚ4»»Á¢ÅÄéÙ /®¤À¾Áv±Ð 3( kó¦ Iú`9&‹E{÷å-²åz0—\+!XÀ÷,­¢18‚†Ã;«a oºéÓ’fºté?W¿?0–Æ£ßïk8Ú‚‹–Š6†õÔSÓd²«¾ð¿P °¼ÊS˜J<ÓÊuÃüa˜àùÒÏ\k³Ù´ßF£k¥G8âo<ËŠVŒ˜‚‹¥ÓHè®$Ó>V*ËÕ#·owwwm  c c±˜1‰|·‹Ï…ã°ÃûK%­bqx·ˆ´<Âè±)µƒMÆKE‰›ÿfqûí¬é4¦'Ÿüac+amÉÓ„Õâ¾ø²<€q:êºë®³ûEoˆ˜wg4™!@Ï{b&­ÎY kîaþÌ¿£Þ!|pp ƒƒƒµgÊw…Ãac&‰!*—Ëkà *Éd¼ïÌ5ÌW¥RÉ@6!õz}-·æŽ{ÖÿƒÁ@ :<<´ï`“ççÉz½n`Ð6ÒK(b±˜1Ø~Ó±i'³m8àMûi”F(õùàã ÈÍB£vµYÄ—5ÑãÁ±ûGÍ"ŽéƒÉ»Óé3Bª>ßp¢Ôä¯t!ægñŽÅbv+Bk&bNò€1œ ̇õèt:Vfö'oxW&,‘`¡_¹vIÆj¡åšN§,L)ˆ(ú‘þÇv ßpxIÅâ/ªZý5Åãuƒ1}[‚àŸû oГOþsM&»ºá†÷+zJãqÄØ"i•·‡fŒç/­FžC$Q±X4†Ö3Ê2´YÓé2‡Ðâ hÃpqã7ªÛíZIŽïg¼Á¨TpNóLx¾•JE…BÁž…×#²©ðZ<óÒy½Ã¢>}ÚîRñl¶<÷•’}<W³ÙT °<‘%—ëë–[ÐC½UÓiTÑèÔ±ÿ‡SLÐñ²½½mQ,ÍfS¥RÉ~'™LZä À&‘ro¿ß7ÓóDµZ]s±Óÿ-ž-ÎÛgŸ}Öäè!©Àè6 “¦ìììèòåËмæÐ$É9?_pï>V©V«YÉÂXaÄÃûò.ЧŸ~Z»»»t‰ÓÁŒ„Îã­\.›¤…Móó €§5ó—g7íd¶ ¸i×Ü(Mø¬5=bø»d2i 'e_Úºz±ƒÁƒµ`A§ŒÈÂ!ÉØ#„ÓìÌÙÃ:›ÆŽ$@’Òß àaQÌòù€T®—=`•’®ð …¬4‹¶ ?½ äݧ˜90¬H²5¥mØM ؇çž{NÒrQH§?«_Öáá»Õlþ¼B¡¬iøXÜ[­–R©ÔóÆ˜ˆž{î]úÚ×>­Å"ª¿ø?U$òðZSÂôÑ7äÃùàé~¿o:8sF­ä†v À¾2›gtœ”x}®×BÉŽßåó\EÒé´•‹¥Õ×8VwÊ´€Õd2©Z­f›€—?טπéBëø&£o±X¨Z­Ú†!›Íš–§-R XÅétjì]»Ý6Éàꕯü?4GõÕ¯þ€]G"‘0 -ºE˜íT*¥F£a`’*ÓNÇXt~½ Ð×l6uåÊ;7¹P(˜C›`3[Þ%×¹³³cL"ï;ã3rÉÿL&“êv»:uê”Å´”J¥µ*ã¯?ÇcCb—T0_‚Ñçú20%d6Dµ°Ù`ãÐjµ,3ÓŸ@$-jæ†ñx¬B¡`ßφ!ª\.e¬£Yõ›M;¹m¿ÛÙ³gmRñÿ¼ï}ï“´d>ð¨X,*‘Hè­o}«._¾¼ö/^Ô[ÞòÓ"ýôOÿ´1#ßió]&`M&B˜mÛ,ðìLY|`Ä0@xÇ+4¢{@!‹,ì áÍžåñl’^àXP½Áa<{Éï¢ ¤d‹Æ Ì$ °ÀL!É€$ …’*‹ }Šž’ nEâ+(iÏçs[H¤% AH‰šS²t.#-þíí}DÆÛõÄ ãã Á n@e±žy&¦ƒƒ¨¯ýÑ•+ïW.÷‡ºùæ¨`ð¼]/,#aÌ’Ìí™J¥ìh/®…þà9øòr$±Ò*ã„`y¶ÜG¯×³~å´ Æ‚xØSú…Ü6²)]©Ñh<Ž–šºmoo«^¯¯•_™LÆÂ¿ŽŽ´¿¿¯R©$I¶QÙÙÙ1w9ÏqJ\ w&“1 U(4ŸÏÕh4ŒIf ´:¥§ßï[ ÷L8=Àéïk 00MD ×Ôét ÜDý æØg ¶Z-ûî¯Ýn«Ñh¨R©Ø{Çf àH2˜ModaŒ0Î0Èz¯\¹b 6™ÇÇÇúæ7¿i㘠X¯!Þ´“Û6%àïÁöÐC­• üq½þõ¯×;ÞñIÒ?øA}ö³ŸÕïýÞï©P(ègögõæ7¿Y?ü°•¬Þô¦7©T*é¾ûîS£ÑÐOüÄOh±Xè×ý׿ãëAÃ…¾ #?Ÿ€‹‰Dìl_ÊÇ^ãÆ®ÚGº0±& ›èw³0y‡‡‡fÆ`¢£|,-)@•’%×ÑívmaÅÕË-ɘ_r],¦IcÁ¦”‡£”<4Ê@è½(?QäûŽÜ;€“…ÊB‹‰kÁy {ÈCËã\oþge2¡ƒƒÿR.üW’þk…Ã5Íç ÍçQ-imm •Hü¹^ô¢ŸÓxüˆÆãåõû<8ÊoápXÍfSñxÜŽ3CK -3é8·Ñh(ŸÏ0Cž‚ñªÙl*›Í˜åž]þ¼aÞ'o¢"††,NÞaþ.™LªP(¨V«™ä Oű…‘ÇgÎçËcûŠÅ¢MÓÈ;Žq@|µÔdÓNfÛÀïÁ£@ûèG?ª¾ð…zÍk^£N§£üãúä'?©þá–$}êSŸÒ™3gtï½÷êî»ïÖ=÷Ü£¯ýëºté’ö÷÷%I¿ú«¿ªw¿ûÝú¥_ú¥5cÃLƒAcrf±fð‹.8oôm”½.Žã”¤Ui ) 7#P»½½m@&…ò,±,Á`P¹\ÎJ¥°ÎYt(­ùIØõ÷û}+‹ú25@‘R.%[tzñx\­VË´=~qðÁN°{§ì,ÉúÚg)|ÚíöšË/“ÉX)–|0X%i¥_ ….iÿ½:{özµÛ/ÑññYmmMµX+}J¹Ü# 'ΊŢ†Ã¡-8|°Y«Õì:“ɤÚí¶Òé´é"ÉŽ£4øÏf³ÆÂÑ¿8ʽ®’rØl6³lH@¾¤çõŽÃµÒåqÎzõÇ«Ñï«Èês<0gcƒë—}±XhooO³ÙÌLüýâã\=þ `Ïdf8›—£åüñ‡„ ' œ4Áõ.È ÝtÓŸë‘GÞ®h´hϯxg¼¶×k;¥£Ùjµ´»»k›šíímu: a†„É"F…²%ã"§©H²£6Ä©‹E›“Ì!ô7™äÂ|s‚ ›‚N§cŽgXBd&Œ6„ÕjÕžI»ÝV©TZ gÌ0€0‹€7~ådÀ©´Ü¤b>cŒ·Z-›×¨ª°©Fº|ù²U>˜ aÿËå²ÞM;Ùm÷ñx¬O}êSzÏ{Þ£­­-=üðÚL&ú‘ùû™ýý}Ýzë­ºÿþû%I<ð€n½õV’t÷ÝwëøøX?üð¿÷»ŽÍÍÊ?Òj§Oyƒ‰ïê`IvX:¥]IJ,”|ø^vòÒê.ÏùÈB°ñÅbq-¦ .ßáM€J 6e® –fÀ3y¸ha%jµšLJRˆìPü‘9žB„&‰x€»/{q-Óé2\Ù/&”—C€È帺 Tê³Êåþ;‹ÿB¥Òï(™ü M§ýµ#­¸Gú€¾"JdggÇô{,®hÆ2™Œr¹œ9'¤8YÒ?9|ޔÜÏçæà„q…•"€šr²wUDa\«|iK[[S ‡s•Âàøãüô;9~þY…B!s÷û}ÓÄÁHa|˜L&fôÀñ › CÄ÷Pfå]é÷ûv2Œl£Ñ°òû-·,Ù¿Çû3ÔŒF#cõç¬R²„…òÑNô[>ŸW:6‡s6›µÍÀÉà(›ÍŠ`qL1ÃpµÛm:uÊ6Mèë层‹ÅÂrý`ñ$YdM04ð‰DlÃá7l™Ë À r"I4U·Û5J._,S:V&“±£Ùúý¾z½žIoÀêóÌûý¾±¨˜M.]ºdòÍfÓ"‘0˜qoÌWh$}Ô › rA©Öð.lÚÉnø=Þ>ó™Ï¨ÝnëÝï~·$Y)+—Ë­ýÜÎÎŽígvvvÖþ>—Ë)‰ØÏüuí#ùˆ2™ŒýsæÌI²t{@4 ­?F²$ À‹ÅŒ©Ô0aÂâÁ‚ùì."M|¾àÉï¤ùneJ_;;;ÆÖÁ¨º¼>ÆÒ;)M¥Ói›È§Óéš“3‚g@)‹E¹³c÷FúŠR·Æ€Ik:,¯¥ƒuB“ècqçgê”ãÛí¶•ìù<‚~WŒaÈ;¯Ùd¡¾r効€†1 þ¡aÛÛÛ³’ ãÐ …T«ÕLaüúüGú 3H4U±XÔ©S§”Ëå t{w(Ùn§N²“m`1—H4uË-è±Ç~D“ɶ1”«#Ûöœ1ó’ÍfÍñ N§¦ñ¤ÀQŠþ¤€!*ÿ|°oµZMÝnw-ÌpÄé|× +Íx¨×뙓J¥”N§•N§Mj2™L¬4Ê{W(¬ßä{{{k-»‘¤+•ŠB¡åyÝÑèò¹B¡`à›Íj0T­VÓ… ló„Ö’ Âýý}£hš1ËñØKÀ-`4ŸÏ[\›úÂxoÚÉlø=Þ>þñëo|ã›÷×5/|—´ößÿ¾Ÿ¹º}èCR§Ó±.]º$I¦ñBí5.0+”•pz¦˜Ü=ûÃn‚àŸò °Æÿ£«’VçñRæÀqŠs’‰¶€²?OYŽÝ:L¥±P(d:4‹,f>²Å—èŸAÆ)(¾ÔÛjµìH9Ÿ5;ÓGYSŠ_¥Uì‹6ñ6Ò*GF€kà‹d¡F™ö•{ô\|©ÓÇS™ƒ”…æ0γôyx’Œ­€µ¡¼×n·í¹r:l2Ñ.Ðù|n~:êððPápXårÙ²%ü‹ÅôéOߦ_ø…»4›…ôs?÷ý³ö½øÅ5ŸÏìü×r¹¬áph‘#ŒwoœbâˆF£Æ´øýI1’LIéÐîfãg‰ù ÄIþL]0Ôwü™8õƒb(²ÓwÊå²mâ`Ða\‘DPjõ†4¤Œ)Æú…çÉûÏç-÷{ÚÞÞV¹\60 PŸÏçvB ¦-´q‡w»]M§Óµ3ƒ™·¼–ÔŸ$Â8ÌbÎñåYËÄF‰ŸgNèt:–ãIɘïâ,iæXwÞ/I*—ËΜ•0ÐÜl6í{è'2ì"U Í3gÎhwwW’¬ä^­V ôoÚÉmø=Ü.\¸ {ï½W?ù“?i¶»»«ñxlZ!ZµZ5Öoww÷Û˜>œxW3ƒ¾Á¸ø$™{–VÍìˆ~™N§¦ È …µ8œÀèâ0KÀœÁ áúóÁªìè™ð(GK²“()²QRñ%”P(d1,¸CÑ`:Ûl6×â=`ÿƒ-HhYÌX„ÑI²3k½&…- ‘g¼<ÓÄ5p=€ENÛ€iÃy‹™†ŠH Ï–Átd³Yår9Ù³eßÞÞ^;¥€ˆŠv»m}é³ÖÎFC­VËôGGG¶˜5›M»&@ÎñññZYv7Ì”\aÈ…ÝnW{{{öÿŒ›UFeHçÏŸÑ?ù'¯ÑG>òZÍf!ýÌÏ|^¿ø‹÷èæ›ŸÑu×±ÏfÑ%ˆÖ%‹©ÙlJZ?©·)æþŽçÈ3>::R¥RQ:¶ðj?öqw»]Ûpú—§~ܧo|ãͦ#@{­©fªÕjvœxÇ °u»]íììè®»îÒ™3gÖ¤t•Òª,‹éæ]ÁÖþ¸?À ¬¿Ï $¬6<*NÛ†„3“óù¼±õNG©TJçγÍeb6˜·<3ìYxÞgÜû”¡¹VÜÒ̇”’ 9GBÉ¿ÛíÚç2±Aãºyß9+¼X,Úf—Àu"€ø¹z½nŸX÷öM;¹m3¾‡ÛïüÎï¨\.ëMoz“ýÙwÜ¡p8¬?û³?³?»råŠüq½úÕ¯–$½êU¯Òã?®+W®ØÏÜsÏ=ÚÞÞÖwÜñ_bcl ÊGµH+&‹Ñ°K~°¡‚Ñ‘´æ öA>ؽ³;æûR©”±(ÞPÁçù >_†C”M¼ ×ÁO† “Åooo[)†Ã⦷Z­5&='âM¸/îÕ!ÂÜ# €Ç)°48†qä² ÏB³ÆÂÓPç:ë€/,Iöýl4è/Ø If¼˜Ò׸™Ñš¥Óiu»]õz½µ’|*•²r4ßO$†gZ°b€| NÇ.€2Ì Æ“åØ‹èÁÓú…_x>ö±¿«ù<¤÷½ïõÁþ®n¾ù…Ã!>}Úe_bGÀ{M$ïX—d8€^6g£íâÙ. ë˜0dµZM/}éç5Gõè£wZF¥6ž‰äjÆ’ Æ4%×p8l%ÕÃÃC5›Í5v³ã‚2.:EÊàµZMßúÖ·,ºÉ>Ê 0x¼›Tè[iY‘@À»Âs‡A£LìYyâg¸7ÆÍ3ÉÉdÒòOég4«ô9l¸ßüÄãq;!¥T*)ŸÏ+YƒÈ¦kBÆãKüÌ·|ßh42ãŒÏ,•¤J¥bò Œoô¬â¦ìüð‡?üáÿ·/bÓ¾ó6ŸÏõîw¿[?þã?¾føˆF£:88ÐoüÆoèöÛoW§ÓÑOýÔO)•Jé—ù—ô‚¼@¿ÿû¿¯{î¹G·Ýv›¾þõ¯ë½ï}¯Þõ®wéGôGÿ£¯áøøXýèG×MŸOFYÅ3j€Bk}™Èƒ-iµPƒ„G¢ IDATÂøÒ‘_ÐóˆD‚øðS®ƒÒ(ef_J†]`²gA#"„Ɇf±XXYŒZØPÀ1lL§y°8ú1׌ɆÓb8y1À|мŽJ’ŸÏ«ÛíªT*™ÛÙ‡Çp3ÀHrMÈ|¨º¯ÈF(2.údúÐl6TΜJÃÜåOÓ8>>6`N%Áëƒý)"€ç^¯g›A~­3Õ ž3™8°¥e…+Nçù|y¾9‘D‹Åž™§T/H7ਸ@  V«¥¯~õ«úЇ>dæ›M;Ymó=Úî½÷^]¼xQïyÏ{¾íï>ö±) éï|§F£‘^÷º×éŸø„-ÐÁ`PŸûÜçôÞ÷¾WwÞy§b±˜~ìÇ~L¿ò+¿ò]]Ë|¾LÔüQ¾ô's0Ñ|9´P(¨Õj™ùÍOº”פ%#HÌ j·Û5¦HZ1°‰ÕjU™LÆÀ‡$s²2‘7 ;s¦Ë» |É|>¯N§cnE®Ÿ’¢oú}%'#°¼‚ìBi„|xxhìf²ßˆ°äú@XrÌ`ѯÁ``¥Atœ|AyÁ: ó›ý1zl |iÎqÐNy—$e²Åba1<h/d 9‘H¨Õj­”ZKÐóBýæo~¿Îû–Þô¦‡ôü©.^ÜÕŸüÉ+T­žÓÖVÀ€ã–ÅÞ/ÔäÍ¡éªår9e2U«Uc?)/SB`b–zÊW¼â5™ÄôÐC¯ÐÖÖ±9Ê lxÀ©TÊâqصZ-+2¹N`Ò'“I5 ûûjµºæPÅbö;rÞYØWž5cÆ”çFöh©T²±Ç†ƒM„?M!úe6Lh}1y0^'“‰:Žvvv씯+¦¿(Û´òŒ1îƒ %6±lH}ùžó&sš?ÞY´ˆT%|H=úD¿aà]Þ´“Û¶>ûaÓ6í;hÝnW™LF;;;6á1)K²É ¥1xvÀ0MÞÉËäÈï²Ó&˜=»fŸ§ÇÂå—$£’,°š…Í3 ülàÊ—´ˆ>`š²&¡Æ€Yz9_.åï¸nŒ€Ê@Þä{CX,ÃÚï÷×ôƒ`±(’-Hy{kkË›€ EŸaFY }š=Î Xâùs¯q’dc€ îL@ë|¾Œyòñ8^+†áv–ûÆ(Àý±©Èf³ì`^ï °öÚLžÇÒ(0ÔÍ7èmoûŠÎž½¬‹wõ¹Ï½LçÏ¿@ÑhÌdl:‹…=·Ñh¤L&cY„’ŒeónZ¢Xö÷÷5¬bi„>::R.—³ç¿Œ+ªëïø¾ò•Õc½QÁ`P‡‡‡Úßß7=c¡ÕjY©µÛí*ŸÏÛx÷¬"1:8Ïy¼A…±k ó…NWZb0(`ÒFÚÛÛ³k æ,ÆÂæ‰q%É4¨¼‹l¼Ãšw>Øfë êv»ŠÑ«¢Qä½ä™1oÐg”­aùøÞú…MD­VS*•Òx<¶ !YŒ5cŽñIù=‰Ø9Ìh£ƒÁàZž%Ì#sßW¯×õ[¿õ[êt:ßqöë¦ýÿ£mJÀ›ö]7_fâöŒ(s±«…ñA¿çw³09”½–Å—r$e9@' >†Ê…€N Ì.-“)ºÅH$²v,LM»Ý6`êC†ù3Ø À¬ åi&ïPððû0„üf ÷I9€íËØÄ[ÀxQþõ}ŠØÒ¿O •…”ÒLĬ„Æ‚ë³ëŒ~Bg›…s–¹/z¦ÍÕ`00 /Éž .¥2L4‘HDµZÍž[>Ÿ7 ô'ÀH²Àg€#ŒýO¹ŽÒ$ ¨•%H˜¨ß/éüùWéÙgOëúë/éõ¯ÿ’n½õ’F£¼&“ëíè>Þ‹Ë—/°¹ú™zƒà„p’FÓŒ¹[oý´r¹¦>ûÙ¿¯p8aŸýçû7¯¿N€>c’ÍL2@¶°âû ×GT ’ ÎWÆXÂw³C CÍýÔyo=`%@úøøX¹\ΘTdz½žå˜N§SÓß¡‡ä]¸“'9Ì-ï7Iü,q-h€a/1,‘áèMOÛW­V%ÉoÌX˜ÈŠÅ¢ÉGÐ;cëõz6·úSQˆ¡Bó•¯|eS>ÁmSÞ´¿‘p ÀnàØdñfƒxŽF—‡–]áOÒ@ïEä€$Ÿ7¸ÔeÍlñfÑ@ N‰—r Œ“$ •dà‡‰¦I’i…$­E¦är9cÚ¤Ëhâ;‰C™ÍfVŽ(³ R¢’d§ãP¯-£t샫Y ÑRÁþ±P–æóÕYÁ°f€QôWèⸯ££# «e±tÒ/\¹‹ä ñ¹hÞpƒú’™w³h‘ýÈø!ŸïtSâ÷ +ÛØÂUÊÏ€a›Í¦1a”ý‰_ñ›˜QÊqý~ßJ¥ÇÇÇj6[šNÏê‰'Né†.êî»ï×»Þõ¯tpð=øàßÕOœÓ`0P¡PÐÙ³g%Éž‰7*°ðÃ6¾{½ž¦‚³•±ÊÆde’hêÖ[¿¨|³"‘¼õ ïq;¼S”Ú-hè0ñÙžým·Ûò`»(¿cŠPÎçsèôéÓ’–ŽwJË|/ï;ã?ŸÏ«Ýn›”÷ÜëÑy“$Àbsúšàƒƒçälr<šÿ(sK2€Ë¬‘5ÈûÛÎ\EßQ*æ;‰t©T*Ö„–ÃJÞvÛmj6›fò o€ö÷÷m#ÈýÁ¦ÃÄn/­‚Ò}šsê¦Ü¶a7í»n0€°e¾té]‹”‚`vØ¥2™M§SLNÞ$ É&;J14X@& 𠳄ΆÒ#”­­-ÓTÁjxÖ…k 4Çï±§¼M‰0|ttdåmÄãù|ÞþfC’¥‹£¦E²²²ÞLÀC‹H™Œëáùøï„5åç68ýi |‹"öz½n¦XU~ƆÓ]ÈX ÂŽ2N(ss-,ZÄ[pÝ|'ôWþbƒ0|°€&yv¹\ÎØïúFÞ˜Ä `ľb±˜éèˆê‰ÅbªV“úÆ7þ¶^ 3gžÕ+_ùêܹ'4æU©¤ †Ì„€NŒƒ¨ôG¬ÁDúl<1šÎ~¿¯W½ê•NWô™Ï¼CñxÖX[/'ÀÜD™ÐÅH¿{ ÁÏñžÓ°v½^ÏÊÐlÌDt»] {þ8‘)åz å£”8ÚÏ3¯hüب0ç²ÐlwñxÜæ›t:mÇ͡ϤŒÍg¥ÓiU«U+¦Ðã]è^1£ôû}3!1Îx׉¾ÁôÅü…¦™ƒéá$þZ¹~úƒJ l;›6uðd· Ü´ïºa‘˜DXd~€)zi¦Ð^% :uÊ&E/’ö9s”B=àBÛ#‹Øô”²Œ ågŸ™LÆvéü‹:%DÀå,@îRØ3ÀŸ˜YDa›0 L§ScQÐõ I|ŸwÝ¢ÁËd2ƶ¼ñ€J€`ޝ»ä™ñ;€×àKcñxÜB–¹ftIk:B@ËÖÖ–åÚÁ¬ ÕyÈ¢F6a$Q©T²qFI=‘H¨Ýn[é Š œßØqhDÞÀud2k€ctcŒu˜\Í@ ¨v;¯/ùv=ýôžÎ{NwÝõzá Ï«R i±x¡R©´õ à ½ ˜ÏçÊåröŒxN”?¹|~ »îú—zì±·èøøÕ,‰æñFo AÒ€öÌkêü¸õ†®ÙlfF ®“ò'&­¤ h «¦ÏѲ™"¿®Õj­ýSTÝ›3úÒo‚üØaJ^)!ôþ˜D/U¡Ÿù{Ÿ½ÇFŒw1NÛw!3X,¦ŸdÎ`ÞÂÐæŸ_¯×3«wŽƒA RgCàçTotòñJlÌ$™1d6›é‘GÙÀÜ6pÓ¾ëdw‹‚ÉÌ=@ 4‹5¥!Î+Ífv ÿOL“±‚e‚óÎaψÁà±x ¿c·ìݾ^,Î} cB_ˆŒë‚éÂ1‹{—>bRgÑ0ù˜'6 ³âÈ\÷ÌçbZñ ¾£/Ó²hþÐk‰Û ¯`+Yˆ1g`šðÚ94€ÕÉÛÚÚZ‹·`Ñç€úˆ1`È®6€ð³,þhœˆ7aÃá7 €jú> Y< ¤/w¾$È5Ó¶5+¶Ü´œÓ#¼D•Ê:}úYÝyçŸëìÙo¨ÝŽk8Ü7Ï‘ñÁó¢¡9es»ÉŸ}ÿ÷ÿk¥ÓUÝÿût|¼°#øÈÁäóxCÃzÁFñN¡µd³Òï÷ L{FVŽ ¿ f|4)—Ë™Œc‹$“x Cp; ÃePž)`þê±Ó CßÇFÏ;qÑÌò®ò= ä]õ%xϾów˜eØ4z@ ¨†5ôåo´Ìž¨£…†™N§Ób‘°`n!Ý0ë«1>úèžà¶qoÚwÝ(“•Ëe‹ ¼¨ññµYpaøYô8ü= “ì?ƒËÑkŒ\^oÆnÛ³$”öÂá°}l$à £1àïÇêv»ÊårVeBf!dAÆA û'­ëî`¢^î›7´øy˜NH§Ók%-~Ÿ~ð À†EŒÝÇyø’¥8iuî0ϰɔ¾ç¹ù…Žë8²Ðz Æw°€ò¹Òúц°4<€ÀÞÞž_¾ÉBíḚ̈§”*1NHK6-n†Ì5ÎZ¥±Ðcê™Ïç=rt4ÒÙ³O땯üSíí=­jõ¬¾üå·èààvÍç+,cŸ…7•Ïç ´Q\2€U½ë]?¯Ç{‡þò/ï´wƒ{åÞxvÒJƒÆFBÒšæ0–ÉdìLcIkÁÚ”@[­–‰„ªÕªö÷÷Õï÷í½ò¬!ã ½`6›U­V³è!N7i4k¥d˜¿Åb¡B¡`NWÞ3 h³ÙÌÜÕl ØLlooÛ9ºŒWâbØœ1æ¼K’é>{¼ÿôÃK_úR5 ?Þ¤l88†qIDP½^W.—³jD&“± 3ñ7l°xOýsôGlòìx1^‘3HåᓟüäÆ|‚ÛÆ²i×ܘ„¼Úk× ’," ŒeSXzÏv0¡1á¡ýa²ä{X¼(MR’Bÿ‚ƒ”E^’éÒ˜è9å@’MÂÝn×&Z@×%âZ%z­ pDƒµX,Ôh4ÌãûÏ_˜ìY¬}ä @ÍàÚ?'XCž‹ :y¥ Mßò»„àâö•d} `Ç‘IÜO6›5†ðÇ8‡Vn¥TÏqz°tô+¿‡U­VMË×ëõL?7NÍ_è©§®×åË?£³gŸÖwü‘Þð†_×áá=öØÛõè£ûšÏ¶©H&“æ¸eLr´%Øp8¬V«¥×¼æßi<Žê‘G^mZF§ˆÐ¯æÁ``ï,Ïp:€%¾„wŽÍc ´»»kÑ7>—ŽPè«ãbȰjlPØ8!‹ˆF£f<áw‘1`N¢<_«Õ‹Å,‡ÒGøp²ZUž'†Nñ€yÃT”ËåÖ blrÈçÎÓöö¶*•Šý9óÙb±Ðþþ¾ž|òId]¢-Æ©K?ú G*•R§ÓQ±X´ ^:6¦m¡?Gw6c6›v²Û†Ü´ïºÁ’';äAºþÍDHiÃ—Š˜0ùŒÅba? _2Á¼`ž¶×ÆàM&“Æ qû㓘„c±˜MÎ ¯«A÷äƒy^0Â1-É=¯™TM§Sííí©^¯Û"âõ@9À¥ŠÐø|ʘ€dÜÅžéàßW;§½f­®C=÷€Gû `B—È5xרñ×ãûŸñ; ð`F“ï§ïB¡$À`6›U¡PÐ`0Ð;ßùN% Ýwß}zúé§!D#FIž€oîW’é$1a•S©”e})ðøøX7Þx£1‚/yÉjw÷iU*×é‹_|£ž~ú&moG¥é÷ûÚÛÛS·Û];Úy@"ÑÔÛÞö³zðÁ·èâÅ¿/i¹)çÿy®~2›ÍÖ+ïa$ÑsÏ=g@ÙF”l6«f³i`£c æ—MM·ÛµMÌx<W­V3ÐØjµ ¬&“I›<;ÉØâ¿‰„ž|òI¥R)«$H23Öl6ÓéÓ§ÕëõŒùbÌòÞqê ï ï,eSú½,aáhRgápXõzÝ€; 10­Vk­D+ÉXÂÝÝ]s63Ït:ËNô›“T*¥Z­fcúÖ[oU½^·@m6’^oüÛ¿ýÛð· ¸i×Ü0[øx5šw›²QÆ”d%À‹ ²Ûíðàw_hùYIV¶…Á‡vZˆ71Xs¹œ†"‘ˆ}%M>“8víÞ00 ¼Œ{&&“9àŽF@4ѵv»m“<}è?Ö†E!¡Ê,¦>FÆÄ7þ ëÅî<ž¥%Çn·kº*€l/@¼FJf0’ $ó]èèø~)?;×Ô›S`ˆC¡ÅéúСQÒæ9?øàƒÇVÚdÜ0NÙ4L&2ÃáPù|~Që÷û ‡Ãö°’œ;íÞa¤ …‚ªÕªJ¥’|WO<ñ^]wÝSºë®{õÖ·þ–*•ëô¥/½YõúË ¤ Áëv»N"‘ˆ¾ïû–§~<úèŠÅ–AÀ;;;uØ”´ÆpN&‹EcOýx ÏÙØôz=Ç‘Hd-”šX$6)0ÓlÆ|l´xöÒ2ʇñFÿ,£M/¼Ã”§a3™ÌšSéQ@FCÒ\U*c@·˜Y¸JÊä’Èý"}ñ’ 6ÇlŠÅ¢êõº'ú”9„³—}¥€¹•wŽ2:™y­åh42ð¹½½­‹/šÑ-d.—³ê ÷¹i'·þïdÓ6í?ÜkÒjróZ*œ•Û}9 p%É€nK_‚%c.imwíóËf³™šÍ¦•@˜ta½žÐ»•¥•yÃ2víÒêÀ,÷êûƒ~€¥#‡Œ’§gÍ< ô Âq&mÊÊ0}Ü?€‡Ïã^`Ùˆ‘ Æ’þô]Ë{ƒ³ö…þ@oÈó%ªƒ¸JtW3Jô) 5Gc~ ¨¢?¸òÔ(3·Z-{®€s´ŒäÊÁ3F‰„âñ¸• 3™Œž~úiU«Uc†“ív[…BA§N2Âd2Ñ•+WT.—í¾2™Œ¦Ó©ŠÅ¢-Ö0“…BÁÅh4ª‹raÃÀO$J¥Òêõ^©?ú£¬ßýÝ÷h>ëMoúM½ñV2ùçŠFW¡Ç½^Ït’4™<£sçþ­¾úÕ»•LîZ‰ÉE8V*•R>Ÿ·q@dÊò÷'¶¹ðÒX0Ikß¹úÞ‰¢Øtðóî–ËeI²Í?Qf í&Ÿ¶•÷†ßñšM/é`¬6 ;òù$]ž“‡¹ÄÃw¶ÛmÓöbÊ`ƒKl œKÆýb±Ð©S§lÞ⺠…‚bÆ(•~/™Lþµ†µZ­fÄB¡`æšÝÝ]ÛhñþsÉl6³0úN¤%˜¤6íd· xÓ¾ë† øê’ Ê›(ÉJ²¥gJ|¤„× yã#[(¹Ô¤øcÑcpÌçs;²‰ÿ¬y  ‹E? Ëx<^–g2™5#  Ø—•Ñ ÑÄXpM”_é˜ï"fñàð,zô?‘üž$[t¸F´`,”˜u¼éÐæ5{d„êÜ‹$»&/¸á~'“ÉDÉdÒL èï`Œ¹_#ô\#¢ü^¯g Ši·ÛÖ¿”¼(×öû}ca¸^¾ àßßß_ ßhrO0.áð*l™±Ëæ`kkyìžÏà›Íf>šÍ–¶¶^¨Ç¹Z­kgç)½üå÷jgçËšNËêvËJ&SV–ŒF£zùË_¹\C<ð~U«mµZÍÞ/NDa,-Ï›ý¿Ø{÷ IÏ«Ìóɬ¬ªÌ¬Êû¥.Ý]êVK²Ú’eÉ–d9F„„ñ0ll<½ÄÂÙÃÀv×"pxO˜EËر;aÖã5Ç"„…,É–,[–ºÛjw·ºëž÷[å¥*3÷ªß©óµ€·ÿÑt¾Ý]•—ï{¿÷ò¼Ïyžs2™Œn¿ýv:uÊ€y½^W·Û5vœyLÿS·—1DžÍ©©)«,k K ›Œd NâG¿‰ÖCk Õe¸Ç›³Ì_žO¯×³Ãaw~ÎÁÐÊ ö ¹™¹¹9ûܯg#9ñ]ªÐ¿ú5ý‹—œ–¬‹€c±È^¨HóG„¥Ñh˜†ÚèŒ5Ižÿp8œä¼ÆÛ„œ´ïIèA..@l§hNß„Ø`”8Í{óˆ×ÒÁa˜™™±,ý°-l¬ä{ÐpÒFüÌF…@V€\d|L¬M&“ „ǦüßC¸L@%& ²„£$Ùf A¸ˆ°œOŠíÝÏü_ÚÅÑhÔ4–~“BEÿ_ м!ćV¥Ãü°»lX€c>Ыɽì½c›ÿ<`/1˜Ð‡0=ä#ㆾ„}N$V® Ö–0 Ï}{{Û!Ïœ“Ól6Õï÷y& r.—3¦Æ…M˜rdÕjÕê #K`ìäóyÓèí˜]¸pR_øÂ¯è _ø€F£ˆ|ð£zÛÛþ7--}]Òø`¾¬é–[žÔ7¾ñu:‡Qúþ- æpOOOëÈ‘#Z\\T"‘ÐÊÊŠŽ=jý{#ì\z@Eõ^G_p ôy/=Ʊìç&cÖÏ)>ǧb¢ž7n×N§c:´T*¥H$bádæ‰×Æmoo›Ý\:V8V©TR¿¿_§Øç$í ÉézÆ>¬(¬, oeeE333Êd2vÁÙãØ³Þô=‡K@(kÏúúz ¿"‡I~>ú2i×f›h'í{Ò¼¨ß§w‘doŸ˜™MŸ_™L™ß¡_уmlÂ}ª_æ @H.3Ÿ •ЬbqÀ`Ö'ifÃãzÑáld±õ¡p>Û3–„ò I ”tòkXÑÁ`ÐO¡%£Éá îv»~¼ +"ä…¹­$LLœwèrmhø¼F0ŸÏ«æ7%6>£\.[ Æ×#“ŠE’i éÓÑhdnmCS‰‚ü{’Œa´ÄøCF1¥ïH;Ã}ÀææÅ©J ŸÞ(•J©ÙlBî€DŸ#‘:Ç™LÆÊ¬Á>îoê¯ÕêêktäÈÝyçÿ«ü¨N:ª§žz«NúŽƒ¨¾õ­ûm®0G‘ÿ’܈¡PHKKK–ˆgÇ•Íf•Ïç ÈÒ]XXйsçŒÄÄ=âF¦¹DÚ1 ”Ïçm¬F#mmm)—Ë©ÙlšÙ'‘H¨V«)Ûa€Zº4(gè_¹\¶ðúââ¢o˜k@êüü¼é7y–2I¤ ³ ÜÙÙ1vŽDæ¬{ÍfÓæ´w7G"Û>UZ?vcXŠÅ¢±øÆŽFûÕ<ϰ¡ô]&“±J0ÈUÐt®F"3ìLÚµÝ&pÒ®ºÁÆH²Åz8h“dÀŒp!ÎLÌlò0M€0¯Ýb!ó)0Ö«À´yF.6Nߤñš&Ò=°@“j†‹ ›P0Z¹ùùù€`AÎ;BÓl:€Ü 0 è´pm®qýÜÎB65rö¡_Dû´;€+ª„À¥)É6é06!Qî‘ûg¡OÐpÁÎrmô%J’m„¤ÝèDWó]®sÆŒà„ö)æçç®g€;!Y¿á¬èc´[h¦Æã±EIɸ¬>¥R)`^h·ÛÊf³ ïì(³ºª×®¯«¸¾®x¿¯éáPÃPH£™µ‹Em=ªÒuשz â…B ëéìì¬ÊåÛõùÏߢ\î9Ýu×ôoþÍÿ)IzúéS·;%éÐQßívU,U(4Õh4ia`Õÿ°è[[[zùå—-°Vä £½ðDHð+¦ua“ccGßÄsEwçõœ€A@°$|]ž±thžA£•N§½Éf³ÖÇ^Šá‚û¡¯IoÃgóý°ÊŒA~ŸL&Í-.ɤ èÌ`n"‘ˆ2™Œ¶··ú/œ¢Ñht¿RJ£¡7ž>­»¾ùM-mm)<kojJ› Ú™Ÿ×hzZ5³·§|¥¢ä™¢‹éÒí·ëô¨rò¤v怷, ó>³4Ôòòi¥ÓçuæÌƒ ¦-Œ¾¸¸hóêMoz“¾ùÍoêâŋַ°»333J§Ózãߨ¹¹9­®®êÌ™3ÚØØ0 |ë­·êÔ©S’¤ 9s&b„×ÅX&¼OÈ–ñƼ“8¸Ä9"… ï"Î^´‡ÞÌ`Ëd2Z]]U,³ÃÏP:”006X7ÐbÑ¡ÎÎÎjuuUÇŽ³ô2äd|úõá{‡ÞÔGÞ™MêòŽz}³×Sò>fµZ5½3ësÙÏÑf³©?þã?ž¤¹†ÛNÚwÝ€©TÊr‡±ø‘_ÅÏ»~½&‰ @@ CæÊ¼y°;¾’,`”pð#‘ˆ*•Šb±˜H6.þÐÀø4`»XÈÉ#ã Åçú<~óóó–<1y*•²¤±lp„ ù>^O_ p—d߀#ÔóáÃß$fÓ•pyr\«Õ²g„îÎk@)ùãè{Ò{2ãÙú$ÀE³³³¦ß|#âgóæ~ÑÌycì ›"Ïl0(“ɘf ¦>f Ïþùç‰Ît4½"­ š@€0@w{{[‹­–Þò⋺ëôiMïîêÙ£Gõòë^§¥%­g2Š%“.å¹%“IÍ4*^¾¬#—/ëæ§ŸVªZUieE/>ð€ÎÞ}·b‰„={ÎýXõ¦&¯O“dÌ]£ÑÐÖÖ–æçç `|hµZ:vì˜666Ôï÷M3ÛéttôèQÝrË- …Bºxñ¢.]ºdãËçi¤ÁðU«U …€«ÎÁÁ×Ö¦¿…hcq¡cÆ‚Éf ‡Ãaåóy Å3vБ2¶··-ŒìÍjh U{¨´ÏpV«UK pÜØØ0ö‘9H3HQïç \__—¤Àaƒ Ì1æ.´¤$¸O§ÓÖ'葜8qB=ôž~úi=þøãJ§Ófõ¬×ëfV‡ªT*úä'?9€×p›ðÁ“vÕ å˦¡wa£#U!`If² ÔÉIØ›><‹çÔÞáˆá“@ûP‡{²²xâõº3X‡f³i‹8,'{Ò;tÙ” ÛÁ¢ƒe#ñnµZ5°HŠD⼟40°‹0„õÒ¤>.¬z%6BÂj0^0’a$˜RLx—1Ÿ%ÉÒiÎæ¹~9Äãq3ãðÝ>W#¬ß]©TìûØôàŒ/Ÿ´;•JY˜“ níÕëuÓÝqÀ€1d\øÃÂüü¼}†ˆ4k5½íìY=ôøãêÎÎêo^ÿzýÝk^£è 7HÚ°³z-ú†°öîî®úѨön»M«·ÞªGßüfݶ±¡Ûþþïõ¯þäOôÚÇÓãïyêGŽh<[(˜>èÐ× ’¥}€Ã¿9 a@ñ²„ .Øóõùã¶··U­V íííiqqQ•J%àö®T*š››3È÷óŠn6‘H0Ì’F£ýúT1~3„ Có[9@µ~i$(¿YÒ;¾ô%­lnêñ»îÒŸß~»Åb ÂJ½^W±XT¹\V¡P°ë¼£‰H¦®¯ëO}JÉRI_ÿÑÕÙùõÆ.2 @ŒOFN ^G_ð öu„ecF+°yëëë6FI¿‚°ÄaŽg„>×ËA8Dx7>sùÊ0q»Ýè8¥Ãšét:PºR©˜œƒÏÛÙÙQ:6³ ’q‹Üƒìq½^×É“' äûÜ¡€QŒ&$v¦ú éjºÝ®¶¶¶,G$2€ß §?Ðò̶··íYäHŽy‡3Ö0¸Õëu[{ùN’…s\þþïÿþ„¼†Û$à¤}×<€¸jÑα¸²¨‘̶ã›ù¿|)$B}#À¿g±“C\lØ”Ëd2Æ€Š† ‰ð2l¬¡VX(À bxØ 6ÞÆÆ»oa¼Âá°mHü Â=ÂxÂJq½T­@(;ýJa$=ØÄÕéü›çC?â–ô®c®×'ªEŸÅæÅ†î]دDOð$ÌÍï>€ Æ ºOÀ›>L—t¨q¢2?ã: KãÐ%y0‡ ØøƒÓS’Ý;U!¦¦¦tëË/ëÿÛS_Ò§â'ô;;šÃ‹OÂÏ%8@R`&±w'Ö…ïÿ~{=ÝñùÏ+wú´.¾á Ú …ÌQËa,Æ áóp8l—{§æm·ÛµJ9„0ќڙ3˜6˜OYì Ì_æà•CS­VS4ÕÒÒ’F£‘ÕmæyÀ˜_»»»Æ¬6»Ý® …‚1½„¼a‘¡páš™ã^BÀÜõk‘\¡[€2‡[æ5‡"¨hryFBa0ï°‚ÌáÄ €|†Ø`ƫժÂá°iY 3ÇX‡Ê岞þùIÀk¸MÀIû® àÊÊŠ…ÒØÙLYèI,Â,޼Ð Š¡a ØÄ=àò†6Ø4¢‘3£Ñ(pâeC‚éó:>Œ,Ö4~ŽYíÚG˜¦v»m€Îƒ+6Vd6i€Ú86 Ø40„@ac¥ù)í´þß’@§ÒÙlÖ6Rß—€G~ ‡Ãsöú-aB°k€MôKh§t<Ó\.g!9Bûè9 F„!q{Çx¡P0½ Lp­V3×' ‘ï‡ÃºõÌýû/Y§¯¿^ÿå~@3©”™üA°°°`À‚T>ob±X4™@,Óææ¦æææ 8åž^?òˆÊ úÊüêåf³ic„¤À€k&.ø;,1<´Z-e³YKSâÝ·Þ=>tùòee³Y°W€B©$w& P.—¥'ÔüÄO([ØñçKB’þ„°(áf2f,b}l£Ì9Ö”f³©›o¾YétZ—.]R­V äg$:Q«Õ,—&"€-à´Z­*•JÙ絚^wJ˜ùâ#0ƒÔ)&a=ãÆ}4)“Éò&’Ì=g&“±Pý#<2a¯á6LÚU7˜:¤¡v‚EšÍ€p.᪜ôI:‹P‰ö fˆ†J¾ù0 ‘…RÚÞŒ )"|,êy$F#æÏä“#48bs‚ù"å›(mS6›5 Àä+ƒá:1…xg5.A6%66NÀÓ•šCÀ' à›~ó®g~Þn·ZFéPSÈ=VzÃ!aŒ¾r‚´¿±¢Çó:Òt:m2˜)›0×Hxrjjʪäóy•J%KFF•Ëå”Éd ¬s°œ7;§÷=þ¸¾~ãz䡇¤ƒPÚ+î¿\.ûEN’¹†éó……;hpØ!ÄûµzÛmzô×]¹RI÷~ä# °Š…BÁÂÔ„3™+"Ðc.//[ÿVù_UczzÚjÅbHU*5›M›£”»CÃHãÐdz œ¹»»_ƒF}mmM•JE—.]2¦+9¬Ï ØbŽÃïììXko#u \ÝÞùKmç……»V\´¬õz]›››$Õ¬y°–ÞuÏ!&‰X­fr‡F"‡IêaI9Ú9ÀÁÒ"wñ†!ƾwíãlöû}Õëõ@„…ëëv»*•J“Rp“6€“võÍ΋›}ýWÀÌ )…ÕYਲH$l¡¦T”¯ (ñ:^ÃFåY˜¯M"Ý:>Ÿ^P···g¡dRˆ 4Ïd2ÆpÏ[ßžµã¾`K e!'{e–~¾Óo0ô%€ŠÍƒ³ív[F#P¯˜2]ù|Þ@÷H$,Ÿw¸J²°«tÈÐzQ<> ß‡½1Æð¯aìàh…E0p=„É‘Hx0‚A}¯× „2ÑDÂ.1Bôû}Ó`aFö«… ‡C ô =¦¯/.êï½Wý#@³V«³Æa}! Ê}*ä Ì—n·kéY(ÝÅ<{)™ÔŸý»§ÂË/ë®O}J©TJ×_½U„@oÈøšžžV¹\¶a„~S0ÔóóóƆvÞ‘ Ëȇûæ»Y¢Ñ¨.]º¤J¥bÏVÑEÙlVÍfSµZÍXFúÀ“Éd¬,Üp8T£Ñ°Äãôl€jzz¿I–}^^£Ï\X\\T<W¹\V¥RQ±X´0/@ ϺåŸE´ƒ-¯çú9àù9'É*Ýt:p©TJNÇÆ2©¨p §Ói•J%;ð¾FâÛϵr8œ´k»M\À“vÕz5Â^€1@¬”wÔ’z! )›ÍªZ­ZHÒç‹ó!óoÀaLZ¯×3ƒü„7¥Ãt&{{{&&çÿ8 çyW, ƒ‹w;·Ûm»&6\X56†V«eIwÙH7Ù½È êu{'¡2Â\lT>”í)û5I·¤ €u%Ï^$±~÷ÆÏ2"Ñ8Ñ/(úŠZäúƒÁá5wóóóÂ’dŒ1›ánÀ!5ï`&±¯wfŠô '3€ws.—S§ÓQ6›ÕL$¢Ÿ}â 5¢Q}ꡇO&5w ×ÚÙÙ±ð›´ö”‹ÆÍWüñ`Î PÓï÷µ"Ùx>Ÿ·ô+æ|ÎJ>€“b„KY§¼–V‡N1ÒÅmèt:J&“ªV«Æô²öööÔjµÉÒc³³³fl!y=}ŹE(žkdM¡ò ,ßx<¶j+0–ÜÏÆ‡Â'íÚmpÒ¾'­ÙljooÏê©z§çÜÜœæçç•H$LDÈ´×ʈ°XbdA&´&ɘIÒ?lj’lAdÃxáKƒв*õB~@`Œfðƒ¶ ð ³ãÓx ÿ!Då“ÑpиmÙ¼½^ CØ’käúø½ï+€8ÀFÕ‹Ïa>ø6(€ UI$Ù½*s¹\ =…wW’ê…çâóÙ¡›#9·7ŠEGZRjðü0k ‡C•J%+ÅæA5ÒØ>tj°^§8 t÷3Ïè¦ ýáÝw+|B¥Ùlª\.k<›ÈŸØ'þ ÃSË\&JÀëaÄy󌪱XLÙlÖ 3¬Ì5 ÌI–º‡9,íkA©°Á³BAª•Z­fÚTÿŒÊå²I\Wô €VŽÅWÊ"hÜ3ëé¤8x1¿ˆ #$¼Ò;áÑ/z†“ÈD¹\¶¹˜J¥¬¾ó¤]»m'íª!Ât Äø–p8láß0ø!Hôn©T*º‚bápü¤ÃP ì›'té0­ ßÏb^†\fÞäBXY:¬3Ìf˜Éd,ÄÍw²ª¼‘bnnÎÜÝnW×_½2™Œ1pvRÐÞ³<0al ãñX‹‹‹Ä»> +Êëaá"ªˆK‡•'(«FÿN”xN[[[jòîW˜o:IØ-ÒÕj5{>7îWu6›µ¹ÐÈçóšO$ô÷ï~·fz=Ýýa€—$Ö0FsssªT*öÝ€fúçÂ¡ãØ±cZ^^V*•zÅ<‘dy1§¦ö«Ï4 cªa]1î ÓÛÛÛ’di_âñ¸ …‚±®°Ç‘tH333*‹fìáš=«Ëá€{†Qe<|pÎúÔ?Œ˜Ðååe‹EûlR½Äb1cð‰„fgg]eDaBãñ¸%Å'©3sÚ§PâZæææl]#üNHŸ9†F•qå¯Á—¬œžž6vZçÒ~BðZ­¦óçÏÿ«ú¤] m'íª!š"_vˆœœ’Óé´‰ÀÙøüÂÎÌæÃæ­^¯«ÓéXŽ0Œ#°†0,¥RÉ@’O‚)óá7^‡ë@ÈÂ0𥯼ë5N›ÎD¯^'Ç&Êæ‰£&а'L›´$c÷¸ô€\_$ $ýEãG>BB^°{9˜5 $D¦Ï$™öчéH»AxÆ”„Ë€ À¥$°30À*CxÓN2™T¯× $Ì&/#Bwhû¼Fð.÷‹ÅT©T,¡îüü¼1ÒàH$¢·­­i éOo½U‰DÂŒ>Væ@اø Ž9bîV9ôŒT±̦ÓiÕëuc«`E«Õªúý¾JѨžû¡Ò?®ÂAŸÃF#ÓÊædî4›Íýp¶ 2&q~öé/Il‰„æææ ÜÂÄÃXrÿžÉƒyô ›Ð7‡XAX_4§ápXÕjÕHØ1æ;‡2ÆD»Ý¶´H’9(ì>16ïE†Âx¼ñýa“}Ä­]³Ù´Œ„³a‘ùw86³ÑÏxl©Z‚vñJÐ x¾2*Bßò‡qþ´k·Mà¤]uCÿãEÌ0|j ~8$‰3µW¥ÃÐ$À&P’áÀ›'r/ð†¥ j4Æd’Ã-H¸`Çu`€ðÉy=÷@ȳÑh‹èC d_vluuÕØH6߯\‡$U0`¤½ð›@aDXô„“¥CÓlzµ+SÄð, §út6¸·qÏâÔžšš2°&ÉîÓ›|ØÔšÍ¦½FRè“2Pé¶w‹ó~˜¯ìt:V-`¶»»«l6kuŸûý¾bá°î?wNà ªÜ+ãPXŸžžÔ{åwÜ`ðî“ ±°Ñ$‰Æ9›Ífmü­ÿàJ’N<ú¨1Ö€4á^¾ƒ>lÐï‘HD«««Æ–ñ^ã ɳBsÉ=£mD«ä@c\c~ð&BÐÌJ¥béTÐÕ®…‰f-`þ–J%«`´V«Xƒ±H¨»\ã ™ë À#eàX;¼+ŸŠ@R:ŽÕîÇãV¿—뤟}‰Dé0±>Œ9 —qBº˜ùùy[‡a)Ù蓚OÚµÙ&pÒ®ºQªÌë¶0Àžqê%$JxÒ'dŇގ…ÆЀQ!•J™>‹Ó.yÛ`LHÓÀ¦Å†EZ 0Vãñ~y64‚0}~Cd¡ŸŸŸ7—2ý@( fˆaBL>¹1l#•¼ŸÓ»w¢Ù£z `‘<@c J@‚¿B˜hŽHŒn !;Â|BcÒa˜›Û±¼¼¬áphìP$±'õh&lžl†°¸Çy挧h4ª…… vƒi“Sl~„ð>á1„üH 3==­¿ùM%{=ýÍk^c¥¿†å·ó!;®­×ëè…ÙÜÝݵÐ/c†P(ÏñÍW¬$»¿ééýJ0•PHï¹G×éK0ì€Æú¹v»meÚŸ°´€Àd2ùŠœp†®d2©¹¹9{N€ñáph‰Š11p?„tÇã±åÿËd2ª×릉#} ÷Èá c†Œ<È.H¦Í(‹–+’q„4ƒg“î5Å5€$÷B:X87Ü`ŸïðkÈ0nš˜ƒ<3Ƭ!FÏÂf2·sssöüXgx-÷+R1>ùq6i×v›ÀI»êÆÌ)qqÑB-0T>a@ -\z>5 ‚jNÒ’lцÙÁý‡-ü SÄ)q¿$ òÞP(dŒaG>  "sNþ„£ýýñ¹˜Px,!¹À¸~WµZ °•žÁCüMˆ‡M‹´ô ŸSP:Ìe˜J¥”L&=óI°q{]€˜P'}I¸Àýùã&Žûe“çšÌ€fÂÁ˜Ð}yc,*l/ “:;Ø>Bü°:Ü‹¤@Å úykkËBã|ß¿¾xQÏçó*¤!üLE†ÙÙY«G KÊckk+ )õŒ) > ñ/€”ð7, çüÌÌŒÎ<ð€¥’Ž?`SÉ È|Èçóæú…i‡Ib>är9 Òg8t™G æÖ3¶¢ªÕª9–9”úpjïííàF£-'º]œÃ’,„îÃ×0¾¬qôýJ¶‚™™w¬°ùƒÁÀ1ÓÓÓ6·›Í¦IøüI»¶ÛNÚU·+˶6#ÜêS‡H2€CN6N¤>çšOŠëpšüK‡º4I&˜æ”n‰ ¿^¯Ûû¼S·&é ép„k9¹R… BÌÎwcRñ`„~{w0¡kôŽüaÓH`¬aÓá5’ì{}~9®Vˆçk P@ÉfX”k;Ä}ºŸÁà°’ý&ë-÷Ã󸢂÷•J%I²° L¿Ÿ™™1†á?Ÿ$¿ôù•a;6G2Bc0I;;; Ç:Y©è[GŽ˜ìàJàÛétT*•T«ÕT¯× @ÀÐT«UËMˆ&gffF—/_6@H(z4issSÛÛÛ='ºÆ­­­ýw7߬A,¦ÌÙ³¶)ŸÏ›ç===­jµªz½naîv»m}Êô¡iyyY±XL<ð€^xá…ÀgÔj5½óï4ýÓ;ßùNÕëõñµ°0Zä„I˜ÖëÇ|… 631$HqÂéN¸™™™€CP`(2¦ ‹©^¯›(MÐ×ׄ½@“£Hás~Ò¾)š>­ÛíÚæéÙØ¾_’ ¯»C?€é¢`ôÐ7ùt%°Üƒthø ÄŽ~»tXÙÁƒXŸ³ ™ÍŒ×6"dßn·-ÄOþ;À+ý¶ [ (õùÎЭ¼Ö¬Óé(€M›DÈ$)æu$®×ëJ¯»î:c}øÖç—Ä“L&•ÜÚR|oO›GŽhssÓ€!ã†Ë§·áÀXáô=iT÷‘ €ÇuâÄ cývvv´µµeŒÔx<ÖÔô´ê×_¯ü¥K¦Uó '$3ÅbÊårJ¥Rºé¦› à3GêɃ47ÉdRÇ7ó F¯áp¨z½nóf~~Þ*UìîîªR©hiiÉXçd2©\.gš@MH"¨‚!‰1[5ï—#ä ‡µµµeáužIê $  òu¯{|ðA½ýío×›ßüfcó%*lÐ>”‡ÍËår*‹Ö·Ìضh4jf¢S§N@%4O”¢×ë©V«ÙšÁ¸‚™ãðÀï¹.dÜæmÔYåD= ”° ~„ IDATÉdì”î¨ac#ð‰z›Í¦d17H2@ c±„%ü|$ÂE4Ø46u¯ƒ]DÓpbƒÚÝݵ$µ|.×Sˆ. ÅwyvãL ,T*•2Æ Ç³Od,2n”ÒaèJ‡ ¯÷R¬œOØ+9¬@ó†ò¸Ñ¯°˜„pùÎ|>ØÌ`AaEø BhÚ¶°+Üc*•²þ+•JÖG>G¨XÚOK„Öm0èuÏìÅÀÈBïkÐõž ˧ê(‹÷“ /--™Þ°=55¥v»­õõuï¾v0­Õj©´²¢ô¹s–Þ„)`ЗB”¤o¼Q§N²j<àpx¿o½^×ÆÆ†jµšjµš&`*Óé´b±˜8ØÐï¾â aÞ~¿¯ÍÍM´Ì5@;k ã”ê4„ä …‚E0H±¦yZÕÅÅE-,,èºë®Ó7Þhà³X,jeeE±XLËËËÆF“È™>‘d,)s¶T*YÄÀWY__·|§˜}ÙÃüqHÃ&"†]GëK ¦½©®T*)N+N›žq„ûqÓ3Æ'áßI“&•@^•íw~çwtìØ1}ò“Ÿ´Ÿ?~Üþ=õ±}L¿ök¿¦û±“$}êSŸÒ‚>ó™Ïèç~îçtúôi}ñ‹_Ô“O>©»ï¾[’ôÈ#èÞ{ïÕÙ³gõš×¼æŸ}=€;Â\lÐdЗdftt»»»VkÓ‹¦wwwmSASÃÂ~eJ’h4j¹ö¼ë×ëx[±‘ÀÔpÊæ;=ÈØÙÙ1f€³„ŽË§3!d…¦.[* ´J¼¦ÏW¤ÀÑÊï`óЕy18âxò‘ᢤ±:åúb±˜…´¨Ö¸òáBî@h‘dìîãééiU*e2ÂRñ¤_|²[If”aCÚÝݵÞÌsâC̸D···Í¸à׫¡"¯‡ƒl6k<Æ2˜ŸcõºJssg2š=¨‹«–¾â}$¢F“….ÏJ&“f0i6›¶¹Þö3†²Ù¬yH:Üét”ÏçšÏÅEÝR*ióìY)•Úw.îééiQÑhTårÙ 3„˜°gŒ ú”Ü?°¡·D[Hî>9žýæ@HXŒ*Œ­~¿¯F£aa}˜E€Ïââ¢] ÏŒhýÎzÄx«Õj§u(ÒÖ֖Μ9£©©)]¾|YÙlVÉdÒæk`Žù¿²²b߃Œ“˜5CK±X4æ›{ãÿh^+•ŠŽ?nµ£É¡Ša%“ÉØaËG`aR=³Î’~`ŽPÙfž´ ø*lŸûÜçtçwêÇüÇU,uÇwè‘G±ß_¸pA›››z衇ìg³³³ºÿþûõÄOH’¾ò•¯(•Jø“¤{î¹G©TÊ^óÏm„_ aÔ50hÞ`‹ÐœqšÅ)ÈæCÀ){<ÛÆƒ†Ë‡a$ÙçBÔÍfÄIºÝn3åóù±°³É(` aÑ`ˆHM Ñ|*•²>€éònc´’,Î>0웎$Kd‹þ©\.ƒÇæ»Ðn·mcBßÇuxÆ5[Ø•l„\½IA’U˜ÀRH‡)B€>‡¹ÁuÞjµ,‡%ÚK6{Ø[œ²ãfµqù²½¿R©¨^¯›M&³gÏêôéÓröc×+zÆñxlå 9X1_ _~© k»JX-@X’ÝÝ]KúLRq2¯×ë æáp¨íím“£0ßZ­–å=wîœ*•Š._¾¬Ë—/@,s@)ɘ9Âɹ\Îúæ*—7·I‡,»gæ=Ãßl6µ¹¹©h4ªõõuÏOXÃ÷û}Õëu[[Ãá°²Ù¬¨m®z£óˆ‡OË3i×n›0€¯Âvþüy}âŸÐ/ýÒ/éWõWõôÓOëýï¿fggõ®w½K›››’dâi zùå—%I›››ÿ`) b±h￲ùP¡$Ó”±¸H‡)ÐðùøÔžY@#Åû¼ A9¬9 0›ŒO™Á"ÌBÇfkÅ5±FÅ ›æµa>ÌÊæBáw½^·ÐL’ÔÉÆ°@ ˆB{Iî9ÏLòÝl.¤2üˆÂÃ! C ££×n·U¯×•N§ (zÖ0ŽÞàŽ±Ý" ˆ7«$“É€9…Ð%Ê`U‰„…òªÕª1hñ$Y8pïÝž `üòù¼*•Š=ØÜr¹(Y³ãó¼Ì£’øw¼³£Ö@ÀÌC»ßï«P(HR`cO$ÆÞùŠ8’,Ä8Œ¢ Åôô´)\Ö×× ¼s˜#;ý[^]Uû àÌÌŒ.]º¤L&c¡FÒÍäóyU«UU«UI „é³ÝÝ]---€ñµ¶qh—J%ÇcsëK2 0æå>¿ ¯½ÁF›Ãó—,‡³R©HdƒN’i´…FC_ùÊWôôÓOÛZåkîh‰DB·ß~{À];Õh4ìyuðÆB®>#Ò‰px¿6sµZ5 ÷ÍgrMäºDì#°×DHüÚÅ5±fq€ý«×ëö<9´MÚµÛ&ðUØF£‘î¼óN}øÃ–$ÝqÇzá…ô‰O|Bïz×»ìu€'öì÷ÿÐk|ûÈG>¢ßüÍß|ÅÏý Ð#äŠé†N’Ÿp–P!Ì×›Ãû¨®@ÚI–Jç ¬TAÞ3®Ó§mñL¢sˆw ÝQ*•2@ Ó)É .0|Õ1†Ã¡…£0hú ¼ðLÚüü¼±Aô+Ì‹:!¬  ™ëña¹p8l%¯irô!Aïâ&T655e ŒpžüiŒ¯á#… )¸?6ùú¼.ç”L&­œzEöƒ…O ÄxcEgY©Ty ëõº’Éäþ¸™Qø 11‡_n –7[Kù yÖˆèëp8¬íím-//[H™CO±X4v­V«Ù<ÁTÂáI’vtpÑDB« détÚ 0gYpsXà Áû³Ù¬±æÈ98|y Á¡0Cx×'?çÏüü¼1r0™Èòùü+jÙÒÇ„¢ÉÇÈ|eìMMMéºë®ÓÆÆFLÂÊ1ÿ9Hò3@&óþüùó*•J¦Sív»Êår¦í#’Ð.ùHY÷šÍ¦™¤ÃŒúœC4ntúÔ—¿äPÊ8áÀ …T­Vµ²²¢Á` |>oFê¯ãŒöŸïçô¤]›m¿ ÛÒÒ’^ûÚ×~vêÔ)]ºtI’´¸¸(I¯`ò¶··\\\ÔÖÖÖ+>»T*½‚9¤}ðƒT£Ñ°?—/_–$"l|¸8}ê 6p/à÷§eX#BU„' i’F†°ÃOˆÅÿí•g*a0†àv”,“榆Œ/!GøŽMá5j0¡þZZ­–±"8ú$™~ɇO9­ò¸˜F€‡´ÊÒé´mt¾p<BŸgàÍ1™LFÍfÓÀ €#@Úk ‹»ýöÛuÇwØuâð|/ ð˜Ÿöz=ÍÎΪV«™‘m&ºPÀµïÓ>€C\Ú^O €H&“Æü8ølÅbа}À À&Ì&ÆÂˆÎ‹%/zc¡a\‡lÜT€Áãµè¨œÚaÞb±˜± {{{*—ËÚÞÞ¶ ͇±ÑØÁ$roœÖ¥}fpvvVù|ÞL ª+Zxm¿ß7­}ÃÈ¡ý¥пá€ðâëv»Ü‡ä‹Åb6¼+”úÀ¾¦ãÞð†7èg~ægôž÷¼ÇDû„¯øLr!º§ÿ·äŠã^éK²ÄÔÐÚµZ-ý~_¹\ÎCtt>‰.€wffFårÙdÝnWkssZìt?¸&4ŸûÙÏê[ßú–Þýîw+ëïx‡¤}Æð­o}«ÞûÞ÷êÉ'ŸÔ“O>©÷¾÷½zøá‡ÿE`If Ûä]q,ê\Ÿïù‚÷„8HèÌ¢îë‘úF|†tÈ.Á"±È³¨sÞ(áÁ‚sÀ)ŸÏ="’‡©ä=’,¤ÂæfŽÍ˜S?š#Ø+ÏRa2A,Ï©Pse¸È³¬0h7ØFBAlÈ}Î:6Qž`†‡þågfJc"+©TJ·Þz«²Ù¬–––ì`@ÚB¢ô ¥¿x¾lV„Ñp±*¢Ñ¨è3ÒlxpÊø•‚½COâb6íz½®R©d zÃ3ssŠŒFºU‡!Smž ˆÙàwË-·˜{–÷^9Žù ˜Ni󦌌" uwwW¥RI.\PþâE­ hÏè úc÷»ººªçŸÞØU3Ƈ6˜¬P(d©l8 ÞÅ8âݿ›3&kÌ=äÖ¼žmzzÚIÓïŒCÒ-qØaÀ¸‚­çBXÀKBkï§/Xsp©3ç0L`9p09ü2~8¸ÂbÃÞÈÆã±¶··m-a~’bÇ»›‘c~ýÁ–׿øâ‹Z[[³Ã*FÆMžñ¤]»m¢|¶»îºKŸýìgõÁ~P¿õ[¿¥'Nècû˜~ê§~Ê^óË¿üËêv»zßûÞ§Z­¦»ï¾[ý×HòéOZïÿûÍ-ü¶·½MÿøÇÿÅ×Óëõ,!GéPhM€!^˜Dçè¼``|I5ÄÒ¤C`q•d'{BÄ€L¼°‡Ë ÊÆMµ €•´¤­@ìv ­,b(R6›5 í³ŸÔçŘX¡–)ÎeZó å×Àçû´"°/QèWúP ³À3„òZ6JOlè€y»Ý6í¦$ܧOŸÖüÁÛÀ B‰¿‘Ð×>ÄFY7Ò„H TNáo^¸â^è&†)d H2%ï£Â 4k³XÔ0RöüyMÝv›] @’þm6›f  :óíùçŸ7ðh…í$tî“þf³Ys©zýÝââb@K¸»»«N§£ãå²¾¼¼¬‹/R†0Ovww Œ!YYYQ·ÛÕ<`ׂ›9“Éå¥0q¹\ÎôrÔÔ¦šÌ*5–ùLrH¢]D/‡“± KºýÁa ¦¬V«)•J S˜™dô-ëcƒùäç„åawvvLZƒ­Ñh¸†=å€R­VÍPä3 n‰JøÃX¯×S±XT­V Õˆ 0Y‘°žë$½y&9ÔpõäI»¶Û¾JÛÃ?¬‡~øý}(Ò‡>ô!}èCúG_“Ífõ§ú§W}-:Ž-Ø’L„OhT$µZÍBe°4h`ÖØD`•Øì}Ô‡1`³Xà¼>‰MfeeEý~_årÙôo+ôA,¸„¡ÙT¸oâ@ha@ˆý'6B×h•Ù’[ŒS·Û „qK§ò½|ƒA DU.—SµZ5&{ÐÁˆ #Ì3ϒ͘0@0ùË/¿¬r¹l,À Gøމ‡°ý˜gSèí²Ù¬677M¿µ³³£B¡`}†Ù€ •ç;R­VMׯ¡¥T**Øôz=]N¥tK½®¿ØÚR·ÛÕ‘#Glü‘êÄ› –——uã7j{{[çÎ ˜TZ”+ƒ‰ŠÇãªT*Æô¡eûR{„‡Ã¡ ý¾ Ý®¾“N›`zzZµZÍÆ$¦œs‰ò¼ÎŸ?¯›nº)Æ¥^¯+šË{0Ô€Itè~q53èŒfŒXSœ±˜›Kûœ8áa‘†1‘€Q>›|‚ÌOdLÒ…ÃaÕj5 ÑÖëu?~Ü´°Ì·|>oÚD/S@ÀüÆ½ÍØ(—ËJ$äÍÞÄ%u’„jµš–——íÞ`ö½© ¶ÒÒÐ9SN.‹™£6}}}={sÒ®Ý6€“ö=iÞ¥¨Ây³„œœ^­VKÝnׄà„Na·<0"Ä"ÆëÙœõ:·Ôj5Û0¨!*)à„C#+áÝÀ| @‘Í”kBÿ—Ífš<„ׄ(^#nHnqLâæææ,uï,û '-NWªuH2ã áUÒ›p_è`QiÉdÒ „ôäƒ#TÆ&äuƒŒ*BŽ0bp½ÜŸ+ÉœÔlè¤MaLø œ­VK…BÁ˜f6}rMÂ*±ñÁ²¹ŽF#KÔLø’CÅWWVô¶^ÐÂm·©sŠ·õÔÔ”¥•Á€sÿý÷ë®»îÒŸýٟٽ”Ëe»4šèÑh¤íímI²~E£Ç|I$ÚÞÞV8Öúúº†R©”î;{VÝ©)=zp_gΜ1 Ñn·eå^º„Nkµš™<2™L€­e\PAc4Ú¯OÌøn·ÛV5PÁóEoæÙ­ ;$Öj5{>¸ë›Í¦#ß7¸v€; ³t˜ tjjÊ"ÌeÂÌD¤}Sù&;¦jµÐ ¢ïEF‚Öc‘—Aäóyce%âs°âßô¡P°T7¼Ï—¦ƒñ…­ÄÌW­Ví1í )%Eýɸ –’gâž´‰pÒ®ºqÚ¥T”t¨åò^@ôyÓ“ Èö!RB·>eÅÎÎŽH6 Àa7,;ܘBª€àU’éÇò^B¢„ƒønNò„:kµšÕ:…AcÆõ+–œc³!}l&Ú(B„¡PÈR´ŒÇc«žAÿ¢G$¬É½÷ íúMBlBÝn×Ü‚Wæó.K¾Ÿg…>‹ëà9 ù ØVþO_ÒÜ0.|?úÑó¡…ÂA¨Œ±¸h·Ûêt:v ¬ÉÏ% fS†1ÿ×dRS£‘î>sÆòÎQ[í( ºc±˜}ôQýùŸÿ¹Îž=«áphPê¶zW&ŒààJu®}ssSårÙæT8ÖîÎŽÞ¶¹©G——Õ;`Üèîü{Wæ]¤U*cаñ°•333Z__7à“H$477gI¥h„6y®ÒauØDÂÔÌc-€-dòݲ˜Ûþs¹_jÛú:Î0b<úh6™;Ið)¢gŒïH$¢b±¨o¼Ñr8²–¡+E¢ ɤ¼ßkaüÉȰ¸¸hL„óÈ4`X‰’øÏ%#ëÞùùyÓtNÚµÛ&pÒ®ºòÄyɆÁ‹ÎÏEØ(`ç‹ÞÙêÚšN§cÉpÑvy' O³ð"ÄÉFS!&fÓÃ]*É6lî ±7a4@ùñ"‘ˆ•è"ñ3ì Ú%˜<Ÿ6F:,™ÅæM €6J>Ç]¸@8ßMµ ÀÌ)?¢Ñ¨¥á¹ÁXøäÒ„ã®düü³f„Ñ€%ö¹ùC¨ æ”Шtb`daa£Ñ¨åW$tˆþŽ0(càÂ&‹á@0XJÒ ›ÕÓÇŽéíîæ-ä3Ñ'Öj5=õÔSj6›êõz* J&“æVÝÞÞ¶°³g¿{½žéÏø?Ï—×RÝc<ëæo[ù~_q°ÙWE!¬ÉòŒÚîî®Õ1ÆS.—Í$Ák$ËårfN ÇŸ×áÂl5›Mu»]ë×jµjsV PÃakccÀ'ÖR¡«õsí]$±:c£‡3Øéñxl3øÿÜÜœ–——µ´´¤Õj5«†ãus^v²µµ¥F£aÏ‚ïà}°ò~ Š¥Ž9rÒ7U«UÅb1---)ZÂé½½=¥ÓiÓw¶óyDЖò…¤^¢y†qÒ®Ý6€“vÕ '/šRoÀ¶áFec¸À|\<(ñ©Qx ÉzÑù4 4ØI˜$Ù‚ŒF†P&5?É»•Ïç•L&-¼D%*k˜œª’¬<šî @q%È…å„‘°ÓéègͬAµ6±~¿o àÓ͵R©Ûá]‡O@—w<“¦Ѹ´BÉ䞬:úŠŸ÷û}c\R©”}¶­è›ŸW>™ÔÏ®­é‰„¾~àö¬×ëÊ!0u’ì>€ÕR©¤—^zI/^ÔêêªY¤„1™‡>TÏï1gp :zô¨î¹çž@:€:ïÁA• 1$H÷"Éܺ¬!ä?Dz÷·— pØ#DH$^‘ŠŠ¾­T*ö~@8ãŒgÈšB:@¦—«À⓸ppŽD"ZXX°>€ ¦q€@Î’J¥lÎ4@ŽD¯]–d‡Ö•¹¹¹Àsá333cÑ€I»vÛNÚU·n·k›„$;ÉŽãÿÒah˜?„½†P &.•d'zÀ#¡?Ø&§c_³ „Þw.!OöH$bZ(Ÿž‚ÏN&“¶Às"ç0z–`ØdaäØä|¶†ŠD“H#Ð'aq&“1§&¬³y‹EûNBÛ°v>íËp8´š×ç]Éìxí¥ÜcpÀ±Kb€Í‚‚Éc£fSàÁøð¹¾’†OO‹Ë3&ÄɦÎ3ƒÁôF@9ݨàÁu¶ÛmËÍF)±—ô啽ëÙguljÊ’ ó,t€sj¹Òä™'“IE£Q?ô)ZR*ÊÐOüÎë]ƒ~èÙgu¼ÛÕÇNž´&Æ¥~¿oŒ´Ô±% -,,˜fSÈ… tᘘf5R÷™yŒ.9ȳ&ßåu×]g)mî©TÊà\ °}ù;$!^·Øëõ,­O5ƒx4iqqÑ€%¹}ª#L"©cxFÒ¾Ç;ï1gÌÏÏÜú¸€yÝh4R:¶õ ¦s4©P(XŸõz=;pPÀDƒ}«O "[²s8óEúÏx^3i×v›úÐ?e´Iû'Z¿ß×oÿöo[åBT,¶8; WH‡IU}¢a6NDòR0q.áDÆùP¯ð 탘;~ÆÈç£g’dà‡°‹2ì\(2g$à`CÙ+˜/´lN܋ϟ¤O†Ã¡"S!}߉b3cm7öôxë–’³Þœ °¤Tàý˜<oüŸÐ „ÏIÆý¡+òº#Ø8€2éD‘w_}q|"‘0Pó€Hžp# „·„¨|eªµ4›Mc‘¼39“ÉØ!Á;;¹OIn0…p\ ×påý0¤.ØÒ¯§Rzë¥K:^­ê±¥%ÅR’ð::žÙ$ÌÛãÇ4ÀŽƒó…w4_™¦×ëé†fSï{ê)ý_'OêK5‡)Ùö“?ù“¦ÓôÎsÆD·ÛU«Õ20¿<ÎÌÌèæ›o¶ºá^_ê‘.<ÐÇèÐh4T©TŒžššR¹\¶Ô,±X̲˜xöbÖÖÖ €“‹† @ëAÏ—DÙ8®ý”ADRëwaaÁ@%ÀÒƒ$À$ë ¡hÆ 7îõc } SOÒlž=RjJÓŒ‘r¹l×LxF’ZÈ’,G) œûlúÛÈpž}öY}ðƒœ8‚¯Ñ6a'íª:"¯]óZ*¯YƒEòÚ/’1èñz6C˜?JØ#Ø­B¡` žv³Ð!h‡9!Ì Ã@.3Ÿû΃I = —Åœ°(쌚„êÑhÔòÕIzEÊ›#©¾>øÖª~å­M½fyJÿû¿}Yjé¥J"àŠ•dÚžÑhp,²!Á b ñš$úú¿ééie2™@-^_L’ Éù? ýåýñci IDATSäxƒ âüD"a`‡žéŒ:¸kÑ-J² v«$Ë}SHø“?G¤\¿×®©n+ƒ»t4i7‘Ðïßz«n¿|Y?ººj©kßÕjUårÙJ’œpÃ3¤$ ×ÅÂQjÍ*÷Kâçév[ïyì1½œHèŠEGñxÜB¯H‚š¸ïd2i9û£È6$é™gž±ð*òœ|€³V«™c0R¯×µººj 3+›ÍjffÆ©;vÌ@-&$ãñXétÚ˜æÙÙY­ÕXL ;x0==mú=î—à ’¨r¸ï­­-Ó2ÜÛÛSxgG¿öÄ*v:ú_ï½Wk›ÿôô´åC|üñÇõÒK/ikkËh®ýJ§D_"‘àAZôµ>#iSèW?¾yNÈ1`œOÌeþ_©TLs  ã3ѵÆb1={ÖÆ8¹ó8hrŸ~³† ×Ç6Ïqç§R)ËÉXâðè«Ã6z'?ó–ëhÁ.2ž`Î)UÉ!%™LªV«)«T*ÙÜìt:J§ÓVM„ç‘Ëå´··Ÿê fV€ ¨#LÌzë£!^súÌ3ÏLÀk¸MÀI»êF¨Î3f#˜+Ÿ3Ï»aqºqBfÃ#ÃÂË"O¨†‡P ÌÕ&h„ð```Y4S©”mvœ¬½sÓ¹´ØÐØ@Ùpø\@áÉT*e¢út:mbìT*e)U¦¦¦ô'OÌj­Vq~OçJ3êõ».ßݘ†yCcèOü’ì·K ˆêùÛë祥@—œnÒaù/696BIVXÞ³„è|¸‹×)ÉRRê¨I £èÃŽh=ý8£éb•µ•SSS* v}äHó¬,†ïšôalÆÇ'NžÔß®¬è_ÿº¼tÉ@+`ÃI)ëûÉØÁP0==­jµjÌf4U¥R1m4ivgG¿ñøã:V¯ë¹ï>=w*êõº¹INGÅbÑ€+º2ªaÀ|ÂŒâfÇE‹+–„ÜÔ¦f® O$:æåçll­V ä1ÄÔnF`CèÐÃÁ €‹ë«Š÷Ëõñ9ÙlV¹\Î>ƒÏóÎé#GŽ(™LÊ)"'F6×H¹255Ðp2þ‡Ã¡\Æ?´t:m¯cNp8d¬¡3¬Õjf âðâ«ý0ÿÐÊ& ¥Ói“ p/¹\ÎÌ8“vm· œ´«n>…@‹rhh÷|†/¾'‚î…P'[ÂRäö"í%ZÏ(° !°öNTßÃõÃx!æfó`1ön^ccœÆkff&Àš™\s„˜Žl2’‹î/Ä‘HD 鈾r!®O~%­{OôôË?ØÓk—¡Ë¸…fffì:z° è*•œøÙìѺÁ R.I¢¹Š¥_yfôÀf­ÑhXª6Xž÷p8T:¶¼ŽÒaÊÿ,Ð)žxV€BtŽ„ØÔ˜Æx#ɽ^Ï6îÝÝ]K¶pqqÑLJ€ûjµjŸ;õŸn»M_:qB¿ðì³zßK/)®Ã„Ö£ÑÈ#NÇžµ]qŠ7›MÞ$ì&}lM¯×Óë»]}äoÿVKí¶~ã¾ûôÜô´ãT*w°a0ÓŒ9@) &Šväõ …B#‘ý:Ëét:ó’DپЉòo:!Þ……h€â………ˆa>H i&“IÍÍÍs‹QˆtPÌtT(l,bò™››S½^„žr¤±bÞ“ÿÓ§NâÃ0«0ÔÚFrá%Ò~hC FÏx£çõÒ€Á``Œ'¬j4U>ŸEäâÒ¥KfÎXúôU‰DBƒÁ@Åb1ÀâOÚµÙ&!àIû®!๹9ÓMÈ`bÐÜùÒa’l#ÂT€#°Fèí! ˆhñX@aŒ|ˆ3Â&‰fmvvÖœz°ilöˆ¹ 5³©²°~"læC¬¤sáúz½ž9úø.âþb½ÏþÌ]›:»Ó_NëÑ33ªìDôÞûšÊÍ´ÚŒi­zwz¬;ïj½1¨K&“¶!²¡žcS#Ü Óâ“ÈÑʼ`MyÞðã?£ôcoö½•d?'¤EIÁ+ÃÖ>מ$vÜa°p«z¢$[>7â•yiŸ¸E£Q3ÿøt%ÝnW³Ñ¨ž[^VCÒÛ¿ýmÝ}þ¼6Ô=p|²ÉK‡µ•)Ïç«X$ ]¾|ÙÒ`€ …BJÍÎê§¾õ-½÷«_Õf<®ßxÃôâÁ8„-/—Ëv`òáç¹¹9sª6$ÔË ßÏ…BA ÊçóðÑ!r8ØÚÚ²p"σCB«¥RÉJÎÎÎ*ŸÏ›Ñ ”:£ÑȘP@¦Œ¬)hiY 8 Á´ÿðÿ°N:e% ‘x-`(2‰niæ™`ïßÑhT«««’d€  F¥©©)¥JòùÔN(Ésº½½m‡ ¤È¼ -&™ ˜_h%ˆ©TÊ"*›››Æ^¢7ŒF£õçk_ûÚ$| ·I)¸I»ê†V ðÖn·Í€á«dÀ޾àg,rhe€CNÄl ,|l€,ÂlÌ82a¶ Kû¡Ë ;vL’ xJ‡ ì‚$®mT˜°8²#—d,(aT6@>C’:ÕÑ/?T×ã2ÚmÅ ÷õgÏÍ*$é7.K¡þÓNL/7æô+•õú£{úÙ­%µ³¶QD"ˉÐjµà¦pCˆŽ sK§ÓÑÎÎŽ…÷4¼æŒïEoI2Zú‰gËgÂÎùZ¨„À /ng“â¹¢=„ÝD? ЂQdqØlÁ\Èq”zÙ`™Ã ,#Œ#Z1 'Ó33úâ©SzvqQxþyýOŸûœ;qBuÓMºtPŠ$Ãá~`’ 3öl€ô^¯§q§£ØÜÔÛ¿ýmwvô_NžÔ_Ýz«Ú½žBîsægô„o_ÍF°ÑhX*Æ ì8Œš1/€Cgéú’,A;Z7ÆÓÊÊJ€õfN › ¸Î%ÙÁ…ùèÇúÓf³iãÌK Í•JEÙlÖž!õ‰©EL´ ^¯+NÛØáÐÉ܇Ie½ ì ×¸ÃøÕh4̵ÎᔹGßO¥Rùĸå`F¥ÿ¼‘0 «áa–™÷‹‹‹iaÞ3‰lLÚµÝ&pÒ¾'Í›&8©sšf#bÁñ)1ЯùT Þ¡Éæ³Cˆ‡!ì áOÒ—°qò¥Î/'rÂlW²’L;à`cöXxY”Ù4`‘¸¿I óùƒµŽ¤4?;Tcu?lÇõ/ìç5ûoÝÐmË]U:M]ŸèŸZÑV}¨™™ýdÔ¸£½ÃškñÚ,Âå€>ú’ëG?óç #>e !öh4j%Ö`à2™ŒZ­V íý üñÞQ‰nRÚ7ë„B!e2 e³Y¤’Lè»Å5Ò¨ƒŠ&QÚ?t ?#DÎÁ‹ë‘D"e³Y…B!mmm)—ËÙØEÞP‡õ›>¨:^?ø­oé__¸ —òy=zê”^<~ÜÆ™¡H“ɤ666´X(h©RÑ›ÏÓ¿:^ñÝ]=[,ê×o¹E[¹œ¦Œ„pÑÌææùÒOÀV1濤ü°{],€˜<ŠtttŒH@ A¢077gFŒ •JÅ4«R8x‡1`fvvÖj@c’ö}¥RQ±X´HF“z½®'žxBívÛBŰû±XL¥RÉÆáââ¢1|ŒGØ<ØPª£0§~8Ë™/ŒKXiÖ˜Ô|>¯Z­fF<£®/ÚK@íp8ÔÚÚš"‘ˆiH···-Iµ×üU* ás8}öú›o¾Y—/_ÖÅ‹Õl6ÿ9Kû¤ýwÜ&pÒ¾'ͳ5lÐÙlV’Œ‰ƒÑƒ¢ 'X@, !<66ï ”dLЕ) a’ ›Ã°Q£ßïkssÓ4€P+ô-‡4 SŃCO4uà 7X%Þ ¬T*6g‘1ŒÇcU*•À!& ©Z­ÜþŒ}*ƒ„B¡@ c–qs3^}etyWêX™ï|ì7@Í,‡Xt¡èwÓétàÐGH2üz…ƳÓéheeEFCÏ<óŒfff”Éd&¥à&m'íê '_ô),È舼S–Ô->ôweòfÞ‹ ý €‚…œÂò¾ZÌ¡-@Ÿé ßíuœ¸½Î‰ð5!$R¨H‡‰Ž1x–‡æöè¾újîŒôÒŒöfR*·Ëºyi¬Ôù”]Ûî`?¬÷bó:}õó%5Z;ššŽjjj¿ß¹7´]’Í%ŒgIØØø=ð`7è@áUÏzð X•xþlŠ<[Ÿ¢€ KC• X)I'Ÿ)í—5ó._ƒŒ'Æ^(2'):5Ÿxà € ÃïHO‚D@’9,¹ÞL&³”ôµcÇôäÒ’®tbcC74:²¹©ÏŸWÌU¤I*'“Z[XÐ7¿ïû´±´¤o&R4ªv¥¢•ùymllØÊf³æÆD^'ç ¦€nn 8@éOŸËÀ É<ÏÝÝ]¥ÓiµÛm-,,(ëòå˰«ÕR.— hö¨Î1U,ÍLxraaÁÆ2ú7?ïíí©ÙlÚ³³~;à‚f~J27Œf8V¹\6FÏ'2'ÝŠ7‘ÁRòLIlÍ\ãÀ—ÄOuE”×kÄD‚D…gÐn·•ËåtáÂ?~Ü"£Ñ~¢çååec394öz=˧Èn6›æ¨ît:J¥RÚÝÝU>ŸW»Ý¶C°t¨‡´k»…Ƭړ6iÿÂÖl6•J¥”Ïç-\ëÓ†°H²MÂç;ƒ)bÑôÎÉV«e9³‹hÔ`âp’/“¼¤ÀfÁI†W1z(^ @A3…Öö  8"äëó ‚ ;dø÷ëû¿¿¡_¸¿,¥Ý݈–R»zêb\_9×wªóº°=TwU8Õ^8©­í²NÀ3õM{{=áOÂt><ˆ‹Øu›gF86­ázTÏÄ 9ìÁXx—*ì ›Ÿè#Oèw#ÆÏ ò·7­:<%‘5×O‚d´X‹‹‹*•J–‚ý¥æ–——íús€TÏD;vÌÆâp0P&Ó(ÖV­¦¹ùyK äŽïc˜¡/777 óý°P6æ|zX[Æ!Ó7¸g“ɤ®¿þz-//+•J*ÁLHN­]Ò®ð¬Ö×סÈaܨT*f~©T*R…8UÑà1VèWÖ@à6àžN§Õjµ.ãd2iãŠÃ˜O=»Oÿ&“I{¤³©TÊrâR©d +ÀŽëEÈÈVŃ˜X¥Ï}#®ÇÎÐLh ×,öµ˜ØÕÛnëèuË=ÝTè)/+’Fcé›kqýûÿ{ÅDál„ˆÜ;NÀÙés–q¾î2i4`Lâñ¸½ž¾'„J…îχÝ=3ÇûAÓÏ0»`ã«eÀÐ"0ç0=ÀfNOO›¦3 F+˜]„‚÷ööT( \Áza‘…ñÐjµtîÜ9?~ÜÆv<·çº»»«l6k‡²T*eÀ/™LªÙl³†Ñ} )æt¨ƒF#HFxd¬U’,áuÆT«Õ²×ñ!¬yôëL¯×S½^ב#G‰DL«‹¼‚C5´777' à5ÞþöÞ=ÆÖë<ï{öý~¿Ìœ9sIH -SÇŒe[”T¥RYŽÅ‘mð°lR#_þ¨ ªVEZÈ1ׄ¦² $–!V$V«”–Û*¶Y—H¢#3")ꂘ*0ù²=Æކ;==5†”ëâÚz½žB¡†jµšI$³TØŒ1žyo½î—÷™dÂáÍqzi6˜©ÎÏÏU.—mlŒ¦cÃDêûë¼dvz `•÷ ÐÆÆ€ï’d™–žÅ¤²ÀXg~J¥Rv^µtæÙR²Æ°s||¬×¾öµ:::²yÓK[Ì\Ór¹´\I~žjl6kúÜ ]íÀ ÝwãŒ[Ê ÞµÇÄC,B$17º2²ã<C?ńΠ€C÷Æî|6›™v‰2¤wú¢ËçóŠÇã–……Þ×ÄçsÄ“wþ¢Gba6læt:ýæD»ùï_ûá¦^÷ÀTÿðÿ½¦Þ4¢å:¢ÿù¿¼­ƒÂ…NÿED_¹ûÍ£ËÎ" …¤xøBÓiÄ>»ßï«T*™S“~¢cÝn×ÎÔmµZÉ‚ƒæã5¼¸ææ2øLPb¥ÔÆyË,n°n$= p ‘ L&»þ&][¡P0Ý›¿Þjµªétº“ Èk0ÇD’PÆ …BjµZë#ÉôTô“ϨÌd2;âô;l úÎL&cÆ t©l8¢”)CRvÈ{&¦æîÝ»¶)â"ˆš2?l†Ê^gƦ€òñÅÅ…^|ñE3Qpˆ4 µ‚ãÔ3S“ÉD½^O¥RI'''* z饗ì¬YLUœ+Í‘s’Ì‚®Ð Ë•ÏçM7‰DtçÎ;Û–qÑn·w¤ ’ì9øãþüi>”¤‘OüºÝ®Åí´Ûm› ¸W6RÞܰBÀgRQ T‹ƒœRn»Ý69U 6)©TÊ@ûÅÅ…*•ŠUšÍæs޾²ÝnKÚHbègXQ6Å̧È0¼)&hW·0h÷ÝБ«Å¤Œu»]Óñ±»fEÛ%mØ ~¿ošvàüŸÜ˜Ð˜ä1 ;úóÊ€J˜EtS€&]>Æ" é…^°’v,³c£$i>èU{ }m¼u¦þWë¯_Ÿê—·¬Ï|#ªx2£TxcŽøü )=}³ï^GB:îGtÚ_î€MN’AØX·z½®Ñh¤P(df°ƒù0 óâwL6+òÈ|¦Í—ö`€až|fúËGñP²b±ÅÌ5z  Õ;Ì}Ø8ì&Â}_®ƒÎf³–áÈ ‡ÃrÑJaFñšRÂŒ½[7•J)N›è]æåryçx1ÝÂX$ʈñϵ`R¹}û¶¢Ñ¨nÞ¼i¡Ú¼/hÑ3ívÛ"‘Ãh:Ùì°qa“ƒÈ†M£$ë"[$™p“Ž9vîððÐ@c‚ûL§ÓZ¯×êv»æªEÊáO'á¹ù,ã6²T*Ù‘ožéŽÇãüŒ|„æO¢©V«¦iD"v|]6›U*•R¯×Óññ±_,êv»:88P³ÙÜ1†Q’HrŠd*ò.²!åÚ/Ë#(•3¯ÒG~n¼zs² (ï6ÈA»º-€A»ïÆY—”ÖÈ}CgƒCV’•½˜`1R°Ø¢wJ$faq¢ü’Ïç-ßOÚêa|ZÐtQò”d‘D©HÛxÎ}Åœ ðZA@O&¾Ôç~ùTÿbVÏ×,ïîZa¡\r¥»Ã¬âÉ´ S}ü§^Ð|=£ÿñÉŠNê 7;ú“FQßh…ô“O<¬îEH‘È& ×롤¾,N¿ó3À‹…Ë—³‹þ¤JÔa—ЇCc ø"ž‚{ØSž;@ÀË÷S>÷®\²×Êå²±s”WéÏ~ñ\ø>¤•JEçççZ,Æú€aáø}ØúÍW«U»G÷ËÓB,J¥R±ÜÇÁ` t:m $åàP(dÒI怯T*;!Æh¹¡PHׯ_W±X4VŠþ$œݪ´=ߘþòàšû’d,ßjµÒ½_Ï IDATÑÑ‘b±˜¹”‰záœ[ο- ºqã†NOOÕn·wòåö÷÷ Ì…ÃasЖaÄ{D®b³Ù4† ý)Æžñx¼ãðît:¦»$·O’IQ¼ f™jR6lZýü ¦Ÿ½6¸Ùl+Œ‰R/Q+ô7y—’ ÄÕëu ‹g!Žˆ9³ì3¥~J¸T_"‘ˆNNNv\ú0j4fz|AÐA `Ðî»]vêRvcÒ‡m`÷J “ îZï¶ v„ #«Ó阀Ÿ¨4NhÒ<ëÅX€iðø£œ`øLbFp,"°Fp `±Øœ°YMô»ÿÕ=}í4­'¾\ÓÅ|«y¬æÃJÆÖ:¥•Žõ¿ýÔ}ö…œþ»ÿë@ãéTo~x w¿©§ð©°ž_ÕtûxjKÉ6…ò!À‹E…xŸCV,­‰KÌÁ²ø|8zèßW”Ó¸w9ǃè­ åT´uÑ^fo`Ÿ`d$8t¥­¦ –@Êó€òü‹“w‚RR*Ì5±ØùØ Ÿ)É÷ù3ãÂG¾`<âzØàŽHy)‚$ËH£Q†ø±8SÒƒ}äȸx88°€aŽÁóåU62þ‹áph d.—ÓÝ»w­¯(¡N§ScÇØà¤Óéàpú† ‚é÷ûj4*‹ös8|“ɤ±½™LÆN.™N§jµZ¦# ãNç³a÷ËãñXƒÁÀB¨ñ˜$Ègô:Ë‹Íy»œØÁ;õõC³œ°Â;qçÎcó˜ƒé © {ñÙŸççç–à師 H пR¥`3@4 ŽR©¤étjï:› æGIÆNòn!ˆÅbêõzv2ss` Zø?õíå߃ÁŽHß»*™ÔÐ4¡9òàÍŸ$á™5&a€¥@J3äı€ð30 hkp è±ÇÓ7vI;%Tô68ñ`ŠÆã±ÈX,¦ÈúLÿû»ŽuXšëø?Rz±¹T:•üfôÆÕù•;Q}ñ¥”þÖ«û:Eõß²¦Ñ,¤ë¹‰þë¿yª·üµ‰þþ¿ªj²Ü–TÑûqgˆ£ÔIé –“²9%Àßx<¶>à9À2Á‹Ţ@N¥(Ø¡Ëq,d“ñ|aHxÎþz)³â@õ€?.S@ÿÐ?€?bZ–Ë¥:Ž 0’äãQƤô—H$”ÏçͤÀÏMX6;JkhKéKxÏÎÎÔï÷54 L›·^¯ÕëõÔëõtqqa›“ñxl‚|JÇþ Yî›øÎÛm·ÛºsçŽmtx’ìÙžˆùø¿Ù𠀇ŽëœÏçj4¦iLJƠ£Ý]¯×Êf³:::R«ÕÒÉɉÚí¶†1[¼·œcÍàyùðo²™êüœ—-àöÍd2;Y•l"`‰àá31žÐÏšÏç ¦ „iÃU,Éâoèïår©Éd²IãKíD2±QÚÛÛÓ­[·T(ìÞ¹sÇÎøFˆŒ $¹¢žL&“æÀ‡…­×릷†m`Ð"øÀ>ðŸú"‚öòlçççú•_ùݸqcGEÉ¿C¥ P´jXœ}~Ç(ÁR n¦ìEYE’ r€”x<®üÁÔOüÄOh<ëK_ú’-°þ2üPá: !‰(¹Ð'þÞ]e+/Bzë·_èïh4•ós-–+ÍfgŠDSúÌ72úö½3=Tëo><Ñ[¿m¢¿û×'zx¡¿÷ñCýûãÈNH²ŸðY,èK@ Ì׃ðç¬0 <²×ÐQÎçsÓʱØÂ¨YˆaíxΔr|‹®ÏÊгøÁ1`*’<@›$@Í#fÑc‚–k¼RƒÉ¡$«Å=r0ÜëõZÃáФžÁ¤äÊûA” æLWŸ£'móüx4˜Jú³^¯h¢ôÌ= {¶ü<`ÖÝk%ô7R ï¶Æ= ðåû0™&öööÌtˆÃÝêM ‹Åbç66&Qg8W,ÖjR.›Öä|­Oýû´Ú“¨bѰ–ëþõ³IýÃÿ§¢o´b6ySRF£Vªˆz)ûuÇßáìTàF‹ÉïOážVÏl6k ˜g‹Ðú2*ì L. :‘02\Â|: ,L Æ@,eNì`J(Å‘;Ç}ÁVzƔҴ=}-'î…ñɵòpHÃ4a”ñ,'nO -lÕèôèwÀ ‡|:Þ‹b±¨p8lAɰÐlj:ŽV«•i)³RΤ,Žáбh±Â´âÇï8,"€—¨$_–¯T*ùÂï´ÛmÓ½ Ë ”¤R©d&õóóó@o®wg5åfŽLãz(õè¥-+'mŒH0{ÜcnµZÙ¦ ïYfÀŸ/=sò Ÿ íP(¤\.gã °ŠÎ1ŸÏ+“ÉØœxzzªããc{Œ+6ÒŸßy'Þ¡ïO_ àÕn0h) M ¦ @”ÏÁ‚Qh_L&M§Bè,@Å5(M^/†f‹ÅZÚ”‹þèþHú§j”ô(¡ ³C7%m`ø‹‹ EÂÒÿù®?Ñ×NSúo?y]§£•^8­jµZêgÿ‹þéãwõÎß¾¡©Š:›Œ4;Ÿk¹œk<é_={]ÿüO¶%ÔÍõÛ7N-Cm<ÛC™‹Ef…{à„N!(‘'É: 6‹7àÆ—ÎYd}™ LŸÂtyvöÆ‘gƒe»üܼkÙ;Š}Ž$€…ÅÚ÷Q$Ü'…xú¨ôôÓOëÙgŸ5@Ì1dŠf25 ½øâ‹ö~`¨üv:Ûì±±ñ)˜ÚÕjeÇÖñÎRö¬0à68hW» `оå˜L&-bB’±€&i{ꥸP(d Î,v¸K ha·M®å+ô^D–H²Ev4a‡AÂ-ìÙD-¶æ‹¥þõ³)ý˧²z©µT"—Òs¢æËˆÞôбþÖ#c}òß%Œ L§³ß½S-Ëo.¼Íç ~ëõz'‡“¸oÏd±¸xQ9%'IæºåÏ0ü·?V Màc>ŸÛõmÇs€Àš¡q# Xd±…±¥ñÿ>Ú‚gpÅ]ÊuÃÐyC Œžw}²1зhùè4¬l:0a*)•£;ÅÜÁ"`$¢ $2‰ “×Yðj·Û&ƒÀ´D‰1Ë1i¾)us,”%p¡æö&L#0ýý~ߌÒÆñK‚ˆ À8Ïš¾´ÇãSBذžžžšË×=ÀìÐ<`hžèlL}ôQÕj5}ãß0v¯\.Û5p’@M#ep<@žŸyäåóù3 s)ŽÙ£TÎ|â¿›1òÔSO àn Ú·Ü€¥RÉX4ʨ6ì”)EàZ­V«¶ˆ2ù@^ÃãÏ f‡Aò™n,RÞGÙ m‹;bL€@v°m,fݳ˜Æç!+;Î/ΉÆô¹ç—Z¬¢ú¯œèû¾}¤O?_’by…´ÒrµÖx<± Ãl6g9]ìÖ¹_@nPoŠ¡Y ¸_˜Jj>ó ¶æƒÅæ€Ïæs¹ú¦‹˜ã} × s”¶™/i«µãºp_#ZçYðyþ^}Y­9s|.›˜ž/ãÐE Æ Ý)`š¾DCÅßüèwŒhå0`:X¨Ñcp`ɳ¤Üà„qÄxñïY·ÛU"‘P¥RQ¿ß·ŸóL.îÓHds2L!×È ‹>Ó3¨<2øxga"ÙD1F)›K2-Üùù¹nܸa}`aðw¸\.­JÀ8&M)Ï:4¬€:t‘oàC’•‚X30Q0쨋Ţ1E¾”Ţ΢‹­T*Ùâk€KЗÊбYèêù…æçÊå úØKúÍSS)µÔ?}ü®2‘‘‘˜rÙ´±¤Ä³°`r6§$+ëñß”ÅO @´´eWa=$Y¼ 8.fÌg`p"<ÔˆàÉšãó)1"ªçZ<8$òô¡é‹_ü¢ö÷÷õ½ßû½VR¤û±ÓSO=¥'Ÿ|RO>ù¤žzê)=þøãßÒµøR H·Û•´™,¤r(ù’@„Èvö0’l2K$VRaGÌdLh±_Ü(ƒ¢‡á³`[`£¼!»÷ø¼N§c»ýhts’„ÅH(¤õj©³éLOüÛŠþ×Ïí)›Xꟿë¶Òá‘zýáŽAÆ»E}Iˆ~º¸ØœÙšJ¥L“çã8lþ\d®Óëõ¸'ÜÎèa\`8V«•i²ü‰ >Ê66¡\.Û÷ðy”Ö1ãÀ²ð¼ÑÂþz0?çK‰”€aÆ(I’}èÌúr-1)Ò¦G6 Ÿ$3!Ìf3‹”AHÃÂçR®§ôŽž ¦> âTbIˆõ€!°µšÏçöÁF ]¿~ÝÀÂóÏ?o¡k×®ˆôXŠÅ¢êõº!Þ­h4jN[ž .Ò 2ù0ø`NⳤmDRŽáp¨^¯§p8lcœï%W°Ûíê™gžÑ—¾ô%›/0yu d³Ä&ÉA8ÞÉxL¥Rª×ëšÍfVžžL&Vb&9€23 Ÿã=ÇJ&“¦o„m4föa"r¹\ GÏdž©  ™ÓT–Ë¥…~ãøeN#€LUXQæ%îq:ªX,êììÌ.ïL,.erÖ/h äeÚ¢ÑèëG[¯×úßø ýÒ/ý’~è‡~H’ô[¿õ[ÚÛÛÓO<¡÷¼ç=úÚ×¾¦'Ÿ|RŸûÜçôØcI’>ò‘è oxƒž}öY=üðÃáë¬Qþ) 꼫•²"‹< \ÀzQ"ÅaÊÄO¸3 .VØ €Z-€ìA©T²  Üt:U¹\¶]»´=& ­œ$c¥Ð§èÒ© ü_>S"ZÕ;nu•O‡ÕnvÛÕjÕ´M|ea‚œbd|¡Íƒ9äìSÊq0„”Ù0Ø|ü‰,>,¤©Tj'v†ÿÞŒ¾çÿ± IÛ`$ÃJð3z<¯ùãÙ0ø3 ·7°PnGïH©š@gá’H$¬D èåó%Y©¶‘¾G7åËnŸ[Yº\.+‹Y†èÃ?¬½½=õz=ÓCöû}ÛØõz=+û²XqR †¹ïܹcÇ J2Ö«\.ÛgP¦È£éC+L$ÇÐL1Á&Sª¦íïïãθf“ÓyùaÞcn£tÌfÅ;į^»[(,¦ˆºIúÅ÷iЮv À—iûú׿®ƒƒ=ôÐCú‘ùݾ}[’ô /¨Ñhèmo{›ýl"‘Лßüf}ö³Ÿ•$ýñÿ± …‚?Izýë_¯B¡`?óç5 þiSJaA&¶€,*Ø;€…’…$ë³Û†maÒDëætaG`{ö÷÷-Fà@¹±Õjøa·ßï÷­¼ ³Å矙HžÅ=QÙlÖØÈp8¬‹ùB‘pH±XBÿÓïÅôC¾®w{b×MNZ³Ù´…}§,ø(~Ï/¶Ø—Ë¥…åzG*§RpˆÀÑ=²ÐÅb1+uz%ÎK&ôUhèX pÍú8À ‡Ò±×‚¡A”ã½ãÞѧ ‡Cï€a4j”þk€TÆ ›74tÞ‰,ÉL€À?}íP£Ñ0 ÌsÇjµZÆ*Ãôr*& 4oô; 9aÃ÷îݳò5@‰ïb“ÀÑc§§§šÍf;l#ϳ¥O@‚×}âŽfãÃ{Á¶°­„ds2‹´ÁÕjU¥RÉ@ æ$â_èW˜9ÞóH$bÇ´ÂïÝ»§Á``1PŒQtÁ Ø^\ædüu:cu™kƒšÍ¦%Í8bcá<Ït+ëääD­VËNkñÏ¡T*óvrr¢p8lóŽ7»ðÀÖ1ŽV«••§aù(!w:u»]‹Ý9::Òd21}#Ìð|>W©T2ö“ÀzŸ° mØãÓÓS‹EU*Ó;û nЮn à˰=öØcúèG?ªßû½ßÓG>ò5 ½ñoT§ÓQ£Ñ$;‹”¶··g×h4T¯×ÿÌçÖëuû™?¯}ðƒ4Í ÀK²X œ£,úÄ< óCCãuZ”Xü½Øß—€)ùÀ6P2†¥€Å´ÐáfqóúÊžQEJ°…°A ˜&©åj­pHJ&ÓšÌ7zŸd2¹£ýªT*¦i‚aäóè3å_ÌÒVIɇò)À0ˆ¾ †‰Å–•gÁ∑ñ<å8Ï4‘Y‡f“üs  …N…øŸóȳ@sˆÞ íÇãÌ»w%Ù³L&“Êçó;9pÜW¿ß7Ѐäx¹_À±8l8X´q¯/ u»]ƒ³ÙÌØÌÄ·H²³”ï€"þÞoX’ɤx€nSrߚͦmô‹0’ì¶½½=íííÙ³óì:Z=ú` ã ˜„Á#Ü9ªV«Ùóädú”r3÷(âß”—yî{{{šÍf*—ËÊd2¦³ ÆV36ÙÀøTæ!6KlX¼œ²H_,v \¥RÙ©äóy‹€j·ÛÖ/ä2ÁR Y‡6ϬT*Ù†Žê…72ñ.äóy +çóyÓøóT(ló„Td±XèîÝ»ýãu˜”ë‘gPêg. ÚÕm|¶ïÿþï×ÿðëÖ­[zë[ߪO~ò“’6¥^ Iò?ô÷ÞÏ\nïÿûíØ·Á` »wïJ’E)x%þM¹Ã——¼À™E•ÅÀâÐ0>¨Ö8J 3Ãùù¹¿8xv-“ÉhooOÕjuÇ`³«pÚëõ,–û¥¼‡€>ŸK¡°•Œ)5Çcs ¢ßAHÙ—2‹^6›5-Æ ÊGc 8æÚùXtD8)SÎ"dÚ›t¸O@7}Êbަˆ……¾¡æµo°œŠqzzªÁ`°Ã^1Á\#ŸPócG’9y 0ddÒQ‚ˆqßççç¦÷ò¥pŒ&Þñ‰~·øxhW£À¿-“ÉèÖ­[úú׿®w¼ã’6,ßµk×ìgšÍ¦±‚ûûû:==ý3ŸÓjµþ sè èåF‰×.àEÜgz!töY‚p)òd¦ym“zá»qRŠñ¹\#š;´`” ¹6âø\¢8T1:Ð(%Ãlv'—”óù\ívÛ@:G Ú:ØÏ,Á¸âñ¸ƒÁ“âŠv g%,åàd‰Z­feK˜)ú& ؆m\­V;Nei[Î÷±4žÙüâ…ÙÅìADF;z9v—qPG+ç]Ѿ”† €K(É@·´ÑlÏ6ñr$çÖÂ&s½^ÏÌ#”ìÁ”tl48é£Ûíš^°T*»Mˆz¯×3^©T,´¸P(ØXç}Z¯×*—ËZ,:991F0 +Ä3óB°Îsdœ1ΖŒ×Z­f œÍZÛH$b w¶Õj£†Y!ëÆ:==µ \¹\6W-c“ ì8cW’U#`Ù<À–1Ž›Í¦±lÞ¼†Ö/ŸÏÛæ&ž{–dc“͢ߌѯ„6ûÓW0ô¬×kU«U{òù¼Öëµêõº*•ŠÖëµnß¾­f³ißÉû<ŸÏ-&‡“W½h÷öö,?2hW» à_v~~®¯}íkºvíšzè!íïïë÷ÿ÷íï/..ôðzãß(IzÃÞ Á` /|á ö3Ÿÿüç5 ìgþ¢R,‹ÍåÒ(“-,ŠwÝòøyB@ ƒ5vÖ¾dËÏÁ˜xcñ)ÒàÜdW¾‡ ¶ÏdA‘¶q ççç¶ £‰Þ‹ë`Ñ¡¯`Î~!¢/ýiôíp84v²Õp8´ï#F‚Ò+Á»&{½žÝ;Qô;b{~‡SK°'°IG‹Æ"€àY÷¾¬ÈBæÇG&“±²=÷˜àp{o`¡ÿ|^!BwÏ|Q¶ƒuÈÀýùgAßÁÈù1Șc¼ù»Ër$có|q.q¼òl"‘ÈNð0eÌÉd¢v»måG>Ö‰Ó9ÂáM¸1ýP*•T*•txxhÌ.e^d€ÿ>Ó`_y?½PìYJI&I$ªV«* zÅ+^¡×¾öµzÍk^cq6lœš”Œ)ezºK®“JÐêòo¿ÁdÎi·Û–—Édìh:t¿lÈw”±é#ÿîG£QKÀ˜â£aÎÏÏ•J¥¬¼ëçžár¹TµZ5ö`N9þ»¾ë»ôö·¿]o{ÛÛ”ÍfU©T$ÉþÒør IDATÊþhú‚M#ß•Ífíô‘ããc=÷ÜsÿÑó{Ðþj¶ úeØ~ñÑœÏ=÷œ~ögVÏ=÷œ>üá«X,j¹\êƒü ~øa-—KýÂ/ü‚îÝ»§ßüÍßT"‘P­VÓç?ÿy=ñÄúÎïüNéÝï~·^÷º×éç~îçþ£¯ƒ hÀ;p„ù—cH$íèNp £Ób·Ì®Úk½ŽÌ %<@ú„ý”)ý¡I’¶š«Ë,.F À óB6›µ’”ÅÁ ³)‰{3 ×ÄbS,ÕjµlqE,ÏËuó™°€L˜/X'úØ3Ž|–w{­ ‹9å2ÀÑ,¬’Œ½âd ñhaJ—?D}¶¡ÿ]oä@ÓH‰—ÏñYœ¡yâ™Ãê}Ç-fƒ@b °°œæAߢ‘äï0¦0æ:Î& ç³ÏÑôAÎè?xŒ J±¼‡ÿüó‡Vaü{êþþ¾úýþŽüÄŸ˜ôÌ3Ïèù矂 ¯p JÀ/Ãvtt¤ýÑU»ÝV­VÓë_ÿz}îsŸÓ< IzßûÞ§étª÷¾÷½êõzzì±Çô©O}Ê…$}ìcÓÏÿüÏ›[ø~àô¡}è[ºÊ«˜(÷Q2á¿%í0 ñxÜŒhÃ0 Œ6X&vý’l· S€ 0Q³ÈÂè$“I›taY`›`Ñ¢]l†=äž(÷Qâ¡´v™ Çãæ¢¦ÄF¹›{˜r/Þ¹çÁ NKÏxÒXhúý¾1,F€ô‡¥Rɘ"\¾ô!‹z0L©ù `›L&íLSw®Õ›|Òé´1(^«È"ëKVÄ×0ŽÒˆø¥mL îb½€wÀÀ'š³l6kyqhÓ`jáY@C×Eȸ$;a†>˜8üák0Ø=íjµ€ Ú}7Ø@{i è°£íb׎(Ç«Ñe’ò®I ¸üÐ- U«U;óÈ{]¡´¡ñš°p8¬½½=ss²˜ h‡Å‘v ¾\L^ $[ŒqÏÂÂèø;\”ÞÝ*mñùytd”špÎö|ÜJ(2ݘ$ÓU-—K+›.(Ãþ`,¸Æ^¯gæÊ£Pê½1°ÌÑd¾ÄÌ5ÊÁ,ÁØR~åó¼ã%ßK‰– Îç´Z-ÜÃöxa¾×ƒR^ /‹¬HúÏŸ¨1™L,üœçÎÏ1nÉ5,—Ëêt:ö`r@Gè.œÏ€ À×M.`6›5Wl¡P°,G€6 Ò¶´o’¬dJÞŽRÏüX`3);z €‘gsvvf%[~øÌÁ` ^xÁίʼn|rrb "±=ápØ$3´oD!ñÌxÙ¤l¯]»f 5` Í!æ™p8lÇ¿q¯WJ×䑎Çc“4°Y¢_øŽóósÓøúM ®ÓÇ‘ŸIÙðG q1˜»ÐŒ’YÈ\ …T*•Ì xç½öæµ ]͘@‚v߉ÄáäÙ%&-€"ÿÏO€Òöt ¿3FÈ€¢ ƒB@ªÏÊC—ä‹"Âjg˜5¿“ö0Ñ8ÑTCCö '"åVJ/’¬äìõy4ƒ%™¾L’Kïþõl}˜£4Ž<“ɨV«Y_…B!ÓÂ¥Óic„<€¹|l߈Ä}É=x¶ ½ °;ˆñ¹/@›7q0†|¹Û3ËÜÿë§üˆq†~’ƒ7ÝCŸ³AðÊôzTrÖ|và‰¿ÇùÉ3äÐè1Fˆ A›Èóƒ‘ä3ùÐkuˆfa׫ƒ! Æa8È÷îÝ3ç×ÌÙ»€;˜KØ-@‹_ði„ÇJ›Ò9‹6›50Ë¢R.—wtóùÜú‘?Sjl±Èñ+X,N8á> møÑO|/q&¾Ì….ÉŸNB û€©Õáû162$YiÖKŠÅ¢Åá°Pq/˜|Ù±;&€†VlʼèÒº0ºôAº^˜O,+ŒÀ )@“²>%Ai릅Ùåž8Ad±XG?ÄIÚa¦¢Ñ¨šÍ¦±hôŸÉ&§ÝnÛæìââBÍfSív[Ï<óŒ%[,U.—ͨszzº#Ù ò&•J©Ñh윸BÙÑŸÈB`5›„b±¨|P7nÜÐþþ¾¢Ñ¨•‘³Ù¬NNNÔl6Í|䃹#‘ˆöööì9îŸgÌ8çÚ)qó,Ø0¢›œN§êv»VöeÁ@Ð'ÏðèèÈžï&*NF„òn³‰]¯×öî¡5Åð–N§uíÚ5›`úaI9í„Ôp8´ Fæ€$•X,fc‰Åd2Q¥RÑþþ¾mbƒvµ[PÚ}7ÏüPêÄ ÓÇùºhÆÎÎά̲Z­L (£\Á„ÌâÍ"íõ`LÊÑhÔœ”“ÉÄÎÝE/èwÝ”«‹M&Z±X´´/_’©¶Z­ÌÉéݶˆûKÒVëS‹ÅT­V5¡Œ h†¥£”x™‰ó±¹\N©TÊÊU0yD¼øßCÔÎ3dÆ£\_ÖRôæúÇ3u”÷0lHÛãaeüýñ¬(¿ÁÀ\Ð/¾Œ—©g=Û¸9ù~4}œ ó+B Pp" ¹m,Ö,Âô3`á=®Uة˚S¾ c“ذHÛÓIÑ’LêKŽh%ÙçúŒMîÓë÷p)°ÎIlh`Ù˜y†x¹\Z\ ¬7?ãX¹\¶÷‚±ÉdT©Ttýúu]\\¨\.k6›™¦ —­l¸ø3aÊ¡PÈÆ5`žÜÄÉdbñ.ãñXõzÝ€±wáò¹héKS(Ì<Âó'W~[.—ê÷û¶Yô¦Ÿõ‰ŽÐ[.—wªlÐ8£™¹3ÚœŽÃ¦÷0”±E‚€n˜ÍwЮv À ý¥4ÊŠdn1™QžÇ‡&ÎG×åM,‹ÅbGÄŒ°Ý›>‰DÂrèÆ_.w²ˆú lÍùù¹ °°Xú–Ë¥ºÝ®W«C/ìgíù;É]œ\à !œ5L)ŽEÀZ(ìT@ P†FNÒs É´#¬“ɤ•]yÅbÑì#åz€à€€¼>I¶°À¡GÌd2Æîæóy=È`KÑC^¨dáñL.ËpZzæÄŸœSå3ú®ô+Œ€ÅŸqD¹à ˆòÈËåR£ÑÈ€'ßnìŒ!¢s`MÑœy·9 y:Ú©"€TòêèÀ—?ÝE’åÏ¡áóú/Àùh4R§Ó1½¿G‰Ú—ú%Ù¤ïO¦áßœ³Í=¤R)=ôÐCºyó¦Âá°êõº}?Ì,ã’Ï»sçŽõ•$K’)ž÷C‹Šd‚ï‡6–:Ž“ìãwx#c Í{À}ánÆ\…‘éú–Óbz½ž¹®a¸c±˜^|ñEM&;f‘M‘gyac±˜¾û»¿[‡‡‡Æ&{G¼ßÌyc`6hW·0h÷Ý(¯°8K[¶ƒÅ—Å“ ZÚ,Ú€¿0É¢‹‚5aò"ðéýñx|g÷ ÉâÀî]P>Ÿ·ˆØÊ‚å#N`ØíRÑsÁú` ¹ôš+"4X”Í([>3™Œ¹|Y¸éSJ{,ÆìúY ù7' š)g¢¥‚½ôÇöQÚ¤tŠ›`”Éd4ŸÏÍÊïRJN¥RÊårögÄøè+}™œ¨Ì3,ÔhOô b{7×èõŽ`ú2€!`SÒŽÁ1ýr¹4€»åY(Ø3ÀÙ„ô3ZC@°†¼°‡°hºX´ù9¾ïö,¥?™#Zø7› /€^¯×3ðÀ»ç÷‡}â$Æï.} £îÝÝ…BAñxÜô·^Â}qÞ-ÏpÎX‚%‹D"ªÕjfÒA’A 9‘-¢x÷˜›(]s/¼w•JÅ@9¬œ7±±b3@ÿøqàžN§J§ÓªÕjJ¥R:<ûì³* ŽN `žM5›ØH$bç8íê¶€ Ú}7„Ç0",¸€)²Ü˜|}& 1»&'Ø3Œ ètüDŒœ’X4U±X´Ò%.UvÚ0Z0E,v, >%Þ*ÉEÀ 1?ÃRÀ`‹ÞL‚Á@³³o“qû( i¿ÈíõzvÞ*‹ ÿ†ƒÉñ  Ö 0È5Æb±ýQ$²9·• a„ù”¨Xù> Æ‹ö`006‘ò9:RIƶ¢ÏPpœ€ÁŸú˜AXÂ4²`{(õ¤kžÉF¶à³á`mù\Vô‡Œž'?ç%€Q8@@›ŸÃ\Ã}Ã8Ìz÷<à Ç}{VpÆçð^†÷žÕ“dŒM Ï+²âF$éààÀúÛoਠÌçsµZ-=÷Üsö~`ú { £^«ÕvŒZ°í8g#‘ˆZ­–½ç·eøÌõz­J¥bzlŒ[0±°»<ç ]ÝÀ Ýw#H††…])óùÜvÆ2²˜„½¸M•$cÑ8+Ó/ÄèÏÆã±ƒ•¢ìž%ЊÇãæv”´“/ÈæK],æ°Þé h@cG)@A9Ü‹³ûØIÆZV0vа?,”H×ëµjµš-L°P„³0QÆHðÝ|6,'@˜>¡pòÒÇ„9{w$}†n   ³Ëâ‹’2 •E—råål6kìF6€GJňá=›éÍ\¯7äÐaM·¾$ íáÚ¹&²"ù}Ïàñœx†hÝ<ð纸FÌ}¿Âtòù|ÞXi€-¥Lú³@‰Ï¾¸¸0]¶ çLS‚¤¤êó'Çã±EÕ‹E[8yqv¿ò•¯Ü‘=°Aéõz …BºvíšmÂá°nß¾½ÓÇ’T¯×U.—%ÉRk.‹Ænžœœh±Øäƒ¢ÃòÁ2b A¿'Ét®0q¼÷’ ¤Ã„2‘o”ËestÃt2fØp±á™0ž—ž-†Íæt•B¡ 7n˜þ8‹Ùý£õ„%„ݦ(yîA»º-€A»ï£àõf”Ÿ˜8mÔ  !X­V‡ŠF£æRCˆ˜z0èèèȘJo’LÏ·\.­¬"m&jJª°j\# ·å.ŒÛå:ø;VWX€?þ S’ià²ÙìNNŸ/ã‡CsEsïhì#懕™Œ±…˜›ÉdbîJ™LÆÀ(`€ÓX|Ö¹p|6 7‹ }•Ï:ô¹z^ ‡ž‹üAú•Í .Ó1(³ñÙ¾\(J$V ó m& ´”8any°¯€3ô°QœCyŸñù|<'€¸/·²‘ì0xOè'Æß‹Þ÷× àäº1ºaêønž§/+s {~#Âæ‡DØ0.¼ù'‹éàà@7oÞ4¦Š¾†‰ôã’`çÑh¤ÃÃCcõV«•i†‰oáaêv»PÉÐcLbËårJ&“–7ÈýÞS¾Çè±Z­T©TtïÞ=›_¸¦d2¹s-lޤÏd2¶¡c#p„¡ãçÂá°m“ɤý7ýÓëõlU(,ZÊ›¼´F󉻰šN§M/´«Û´ûn”!ÑtIÛ£¾*•Š1I(ŸXKž‹™?º‰Ïòæ†õz­V«eÀ‰EÀE|:2˜Ë,'$À|°HQvõ“* %5I¶¸#rgÑ‘d€•³A1ÀÊñ_ÊP>,šÜ:þL4´®ðŒa>Ÿ·&º?˜JÀŸËgH²lÊY&ïr¤„Hî ÷/ÌL°ÏKäºýI$üìz½6¦Ðõ(¹Jµþ>J•>·‘ÏJ$ö¬(YòÌù 4rèÑ”I²r.RÊ䘕¢Ñ¨±s¡PȾ«V«™ŽŒ1Fµ··gŒ1ÎaÆ¿Ïôeçñxl€y‚°s0}þy’u‡ù‡S*üQlh )O²´F"cä¥m81 Žñ³úªW½ÊØEú“÷œX =ŒÆh&“±È(~Çk`¼½V–´ÓéX<”—¨p_|Ì!ɰ½lRÐ2ÁÄxàšëôý‹É„w¶öùï;›ål6»óØ€…ÃaݼkÄWym/?ó 3 «˜@‚À Ýw£<æÏ ¥Qbá1ÃÌâCé &Ä/r#(…¡‡‘¶ŽE\ŒÒ¶¤%É5ʃ¸'YhѤ¡¥òÇ;¡»Y,;±(€.ts,ŠLÚårY«ÕÊJÓÜŸ/ÛrŽ2º=îƒLD@ìš/ë±²H³à°PÂ2Â(P.eA¤SŠÀñy4J±,z,ðhýI"å¤2ßЪ1~.<´Qô9À›IÐLáže·cî2™ÌNh¼×[ú±G5=.×Àýòþ0줣^¯ïá‚vu[ƒvßÅA’ebyÌ—uÓé´Å¡(Z­–-ˆèa€(¡±3xí­$; „|7&AÏ‚,(û°ho `Â%’ @œ ÛbÒg¸|àÃ;xX:ÊrKEÙЗÖ<¸¦o¹ÀV.—ÛÉ/ƒ¹“¶GqÆ%ƒ@ùç2;IóQ,@~Áçzø;ô€¾|èÝ«”;ÑŒI²€wÀJ2&€ÖÏ÷ !Àü™gÁuS›L&¦ÅXr sf- 2¨$k°nÞ ``LÁ¸¢µôÌ ×W¯×wÊÏèý‚=â3îa.9êϳž|>®xb„øLX(J¥¾?x¾^·ÆxX,Æ’s”"±@èwq_ó;€."_ÐÕñÌ1ëx L1GGGv/Œ™p8lÎu²?5…y¤ÙlîÜì=¥\úŒ’2}Ïï•ËeëcÞò'Ù3wñžÙ|Äw0NÐ ò¾ÓÌs?GY9#ÉF›Êˆ×ASò¦ì ´«Ý´ûnhÈ..6GÁ®Ž(‹D£QµZ-c€`:<“Àd ‹Àî6ŸÏ›®W­_+>là ¨ô E¥R±I’²"º7I;çef³Ycyˆf¶%5Ø Êkèæ`ںݮ]'gpLÞ+~(/3±ÃÀPÒ‘dß'mKç,Z䆭×k°0ް ,P€_X%\Èh±|˜09};Ï!®gA¤Ï¸6_¾¦Œˆñ‹ 7ÁÞxg3¦ʳ¾œïuq4´©ÄlÐ'0)ÞE À ˜÷ù‹ÅÂúí¦/9K[­,ÏÖ‡¿ãçïü<®TÀL4z4´†\gÄÙðÀzà nùÿ0ã°¨·û2&ïF!@ew€ $Óœ®V+]¿~Ýúžwa>Ÿ çr9;çˆ9ÄKx/F£‘^ñŠWØ;Ę …Bª×ë¶¹"š‰MàüæÍ›;'ˆ0ç [UL&“V~E§Ì=¡¯dår9Ós¯°®€5Lþ?,/Æ(ä+¼gŒâ8&>§Ñh˜Ì€÷ LJÁh4R,S£ÑP¿ß·{¿¹ ÚÕlA`Ðî»õû}‹E[p¤­ËW"‹Ñ4¿ûeñ@¯‚®Š2!–ÏIcfñ¡4ÄÏú²-‹)ñ&—õcD/°£- lõ%kŽzònAœ¶’L ká‚‚q’´ãDFfÖ ?(­ãæ¸ÑÑ8¥­ ­‹~2™T§ÓÙYDÞ°èN( ìG 4ÀG_Á°¢wÌf³VºÄ Â={Â}±ˆRê÷Ú=f_\ÀÀ_דyçx<Þ9yáââÂÊóŒGoŽ­^­6'^øü>¾ ÊFŒ’"%_fL@f‡2)ãûôcšñˆ´€{dCK€~ÇÍÏRÕˆÇãæÊ===56ÜoØ‚T)h”ˆaq‰„ÅB1g0?1f*•Š=ÞYd½^ÏÞ/ž—g̃v5[Àí¾[>Ÿ7a1,†/Múô}mï–d ¥¼ÑhdeCØ!I¶û\3þ(Ýxד.Z+Ì &î–d»ot;ž5ƒ-Øø\ADòÏÐüP›L&ößÄ{v8­a¹Üö>›ÍL «Á (@ç‡~”Å”ÊMôŒ…$Ó±øs”Y4è ØØ@ 0åYU©T²kà¹Ãp^\\ØÂ ÛûW(¬| È£ÿ;è½øŒß7¶\.mñæçØ” Ñô9…€´œ€^þŽ÷™Àjµub<{Œ‘²)c Æ0CßÂ$ Xh"ùÿŒ\¹ÝnwçÚÎÎÎT­VÍyJys€ûL§Óf¨áýv»]s1sݸ¯)wó³l`xnÞÕ;™LL+È¦Ô Ó&mrþxדápXö>¡ï£„Îü5ŸÏU­V-ÚC4 IDATÛòüüÜœÇétÚâa(‘ïïïï”öa+§Ó©ŠÅ¢$B œgëË3===µ9µ×ëí8Ý)÷3f|0|Юn `ÐþRš+"Êc06èÓØ%.“ÉØè|ŒÎW€n>"KX …‚F¿k§4çÏ6%« ÀÃâïK¥Ò6[V ɵ±Ø°8³P4H2§ôÙÙÙËÈI”CY¼kµšYÊÌ,è~÷N¿x€ SèM3€qIÖ÷,š”Ò1`†à„%åKÀ3ÌåqŽ‚Á0RBó¥O4—ÅbQ>ú¨À ô~!§îY?² a».ƒ˜*ΊöÚvâÊc”}a¥|W¡P°ÐøÁì°ë^¯×VEÆ„‰+Pˆù0çcV¼Ð߃î‰ÿFG .e®…E<ŸÏk8î€)º9ú1›ÍZ4 ßÇÒ9š5ôB¾tºX,LãƒG?Ã&À¢ôZ!® é’X\?‹ !;€TúæyÈË´Šó¢níßÒl:S<·û†Ý\¯×Z'× ‡ÂŠÆ¢š¥fJ$:Ÿk±ÜÜeÔéÙTËÕt›;yµÖj½2vo:ê‡ýØ:µ¶ø6«òJ«õʾ¿9lêtvjÏœ† F’{fLÑl ˆ!º¬`À 6ÒYXJì¼ >`²µ?ZΗ0aaó¼Áˆ1ÇFÉ—™æŒž©g2 n·Ûêt:zðÁíÞ¤m1G£P.wµÚͰÁÁ0# €÷ï æ2i‘f0¦Ñ¡²A%v –P¦ßòlÜ`Ãa\½ä…ϸ¶Z-375›M ‡Cs—Nò\;cŠÓCêõºLÐÈ\˜Ëå4N ôûê sãˆ8ÊÞA»Ú-€A»ïÆÏ„S.—M,Í‚9ŒaWK…]>Ú9h4Qü»ûr¹l7˜¿kg!”¶îQC&[˜n·k»tJa°^“á³Ò$íhàÐöZ탢q?¢“ƒådbfÁ÷¡×€+€, ™eô7åR¯ÿCÜc×ívµ··gXX€(}¸çïÐÓÁL icôQúC àüü\‡ÅC}üï|\©Øÿ¿õHÓùTïøw¨1i° ÷ò!Q@Œ?6@”o¾D?™L¬ìÉ‚N?Âv`Ëø<6dXòœyù=¤Ï牂äxðÂÅ)‰DŒ=™.mÇ 7ÆäÍ›7wLEý~ߎƒkµZV²…!åûÂá°å$ÂxÚ#‘ˆƒJ¥’CúŸ#%¹ol"ýŸ$²‰`d¢¤`—ýyÅ£¸··g›% *Ì0ð•Je' €¸!XUïöGPFJÿ,›:ŽqÐÕj¦§ÄÙ^©T,Å`±X˜IΛłvu[ƒvß f€I÷èèÈÊ©€:Ê0žõcQó¯­a"/ ¶è¡¡! ¶+›³&`*ÉvÉÞt"ÉÊc°°)—ƒRùŒ×2Â8|r¹œ±}0+’l±ü±›ç^qëQô&J¸,–,Ê00;<o¶€Ùìt:Z­Vª×ëJ$j4fnÁ|üqÍ<ÊÛ”E=“Éâx¤ @aæ¤R)E¥b)½ïÿ~ŸŽ&G;eqáä)_JÒl:“BÂ5ÀêòóèY¤)aŸŸŸ+¤Vë ÈåršžM‰FŒ1ŠF¢šÎ6ãå•åWê×¾ï×THt<:¶û‚Ý¡$=T(Ìqqq¡½½=…B! s”C×ëµêõº-μdz C˜p8¶<;ú‡S—gäõ–’Œ½ z†–Žë€™ãYŸŸ›Þ”1Ʀ¦\.+“ɨÝnïPÐÑQňÀæ¡P(˜ãæ/N[Ì c¼>Ø®Édb¥ô—^zI‡‡‡ö»€äW¿úÕúŽïøår9}úÓŸÖ³Ï>kcm-¦% ‰24ßżſ-•JËH–â|>W¹\¶w‡w•þ ìËf 6Ük–=Ïæ±×ëÙ¸õæ±Ñhd‘OÒ6’>ÏÍ%åa@íd2±MtЮn `Ð(ñrz8vÓhÇ< ÇÄ“%ÉN€™Ç0Ñeaº`Ñ—d"zLLˆìÞ)%2ÑzQ»ÏÉ£¬ˆ@Å=ˆ``I`P¸OØ*€´=QM˜ÿ]Ê_hñ(Çãñ޾®\.Û)&±XÌ2 Y¸#‘ˆÚí¶&€ÁÔþh>i{‚ €žgK™*ŸÏ›æ6-åQ€:7Ct{’ôÒð%}½ÿuI2e(²ØŒðEX‹ÁÂÌ3è4jÀtµZ(…9Ü$“I÷·f6&£ÑH¡^Èûjµ²>H§Ó›H£ÕÚž±ÞÔÂ8"Λ.J”è%Ù8â3y?¤íBÎwI²ñï³ô(%òœcH `3h>‹…J¥’™ èoŒô %X¯o„­äÝú20gÕÂÜZ?!½ð ¿X,šî U¯×­`ã„Øííí©Ûíª^¯›ñÀDt”Ïd®ábJð¼Óü ã €ãˆéƒj‚g³ XçãÙ1¯$“I‹E¿’lþÉçóöþ1ÇQa€i\.—ö,J¥’±½0ÏNG…Baç¿G£‘•…Ù¨1>ý9hW³0h÷Ý"€˜L¤-A‹‹#ˆ³–HIÁBÃbÊ¢O ‚?Æ @ÆŸçó¹%öÃ@ ØQ3éJ²r& œ»€PB#‘Íi,®,’ˆ¸a6pòù3‰YÀ‡Ã¡±+ÄÓøðcX@2Ú7Ž«£<\«ÕÌ- ¨ä~¼i+‰¨ÑhØÂ#ȸœ_ÆÂĵ©R©“éÝДa0<àö‘9^3ʹ„L:î ÎX‚eÄè@Yœ~¤l†“f‘x‡7#œ`“H$”ËoX–‹ó âõ±!l(Òé´9L}|ÏÑ;¸¥ ÀÄ ¸ÃÅ óEß#mÊ”y`’|J.—³Ï’d÷‡~Œþl`òç' +;”!‘ ø}®b,3㠆䰃ý~ßrÿápØ‚Êqh³‚¹C?‰3Ö¿“£ÑH×®]ÓÝ»wMëzûömI²ñŽ †¥mܹ<¯jµj ~y…´eÓ˜›Ðêáøç™ÁäRáàZ(9ãXfnÂ}î7l–c±˜EóЯ¼Gׯ_W¿ß·H F0àlT¼î1hW».à Ýw€¡%ò*‹¥œ…0d,Ò0kÒ6ÃÅ–3r™Ø˜}4“-R¾ƒÉ]$#Là/˜?2alÐ_á6F´Ïu¢“ƒ#k 2ú#JD0'¸u9¢ Æ‚R;w+#úmO¡P°0ZJH>È–ÏáY”"‘ˆòù¼ÌÀkà¯V ·ðx<¶šV0ûŠ> Y4µ¨®“gÈ ‡ÃÆžPÒö:+6,hœ0ó¥oaU`_ù~¾“ì>6”%ab ’´X.vN¥¡ÌÇU©T‰DìÄú—ñ„€ÊçRÒE+Ƶòw þ›{†Qò§\ð{’l€9ÐâM?Œ\.gæ{ùž‰¦¡Ùåý¢¿ÈÐL$ªT*zä‘GôÊW¾Òþ>ª\.8‡ÃöNb$0I›ò'ñ/ó™Ï˜ô6‘þ§”¿\.upp z½nN\X4Æ<úFÞAo8cLQz- zðÁmƒ»J)-3sŠïWXEïœ'•S¿ƒ¬ÅK?x‡¥˜ó”™Gs÷ìA»º-`ƒvß Æ¤JY†ªÝn[ Öƒ€¶Í¡©ËåÒvÒ‘HÄU=àƒå€ñq+”:1m ©¹|ýè)Q£¹ògs²X°OI Ó ÷ÂŽÞg¼,`J¥’hXè)¥Ó­†Q¡”£ …,‹QÚ° '''Ö/ƒÁÀ~¯M$ÌÇ! ‰Háúa2a{½Þ€†Ý€E¥F¦‚•ÅÓQ¸Ì0€OXO²äXx¹&ZˆDa±ô'HñãKYóeOœ¢<ƒX,¦Õr{Z‡´-Q3f*•б1”-–„ô¢5C³J¦L¬/½Š 0DûGÎ"`1—Ë©ÓéXÿû³›% pÁ\Q©T4N-¿çÃf G-ÇŽaVbæÍ?œÕM©»Z­jßžy—¼_þù1þ}~Ÿ×ƆB!µÛm;®×ë)›Íš±Œr³wµ2FÙ8¬V+ØÉ|6sP³ÙT·Ûµy‡p{Ì\h9¶²X,šÎ{¡¤> Œ±fƒ‹ÅÔjµ,.‡9ªÕj)‘HX¹– B¡PP¯×S±XT£Ñ0V‘ûa¼²IÍf³êt:ã3­¯p–Xa@y'‚vu[ƒvß Æ‚ŒË öŠ8 X/PçgV«MF›wÄù“CÐ I²R“0× A0](vŒ ^C8e§¼ÅµaÜ€¹ñ'dPöŽF£6I€¸N ,v—‡‹†>™Ïçæ”&Æ€cì¼ûR’-üþYÀ¼‡ò*G›ÁÄÍçs U«UëcbJ,œ0ˆ×¥mä &e]$Ü$þ,i‡1¤æY4~ŸìAb-üçÁ†¤R)+Õâ$‡µ•d¥yÿÙ”B”ç‹…â‰í†0¢œF™7*Ú+i[‚FÂÀõÐ`·ýØ“´ã¬Æåß1ÊçlT¸_˜ÓX,¶Ó'è*awÑ¢bv`ÂØò‘"|àØ¢_`Hx¡øy£ à¼T*Y_-—K 2Åbæzå½›L&*‹Æ|I°ÅØös×iR^],ª×ëšL&väãŸ1ή×ë6ot»] µZ-+«³AcÌ"Áðxž9Ñ+l`¼—È#¤ «‡sz¹\šNÒoa0yçä²?ãñ¸mæZ­–½O˜|êõúŸ™ËƒvµZPÚ}7&,I;%Šr¹l»N :NX`!DsÇwNv€…ÂÐÀ¤ˆLÚž•K™R ø€J¸þØ/@)ßËî}“7© ?¤¤85­ÔKé‡%= ”gaX¤Qô#`Ògα8O&“0^˜(iýÀEëvÙñ×ëõ”ÏçmQ@Ø~pp`ù‰˜øØDúi<«×ë``Ññ÷3‡KÖÏ£aÁ~þÇu)m \.—êt:’dŒ:?>0P&–¶Gòùªh4ªjµªV«µ39V«U[pÐI2äûÜz—>ïæËƒÜ "zž [Ã}‹E‹ná\å;®‡¬DXX&þž€aÊá<+þ^ÒŽaÐÇ=Iº··g%YÊþ>‡ MÔ‘ÉÉ ý~߮ߛ¤ Ȫ×ëö\`7ü˜á‰! ÁèJ2Fÿb–A“ s˜ˆ' ÌÁ²øÐzf'š±‰kÃ(ˆC¯éóþ¸f¢À¦ ° Ðã=„¡ØÂ1Æ`ñ@d‹ÅÂN‘à:¸&J¢€}€1L Ç¥ÓiÝ»wOFC…BÁúÖër›Í¦9È170†yV’ „½îu¯S»ÝÖ‹/¾h¬·×Uò>‚`±1tÀ®6›MsrXjœíT#NOOwÎ1–¶›ZÜÈñx\ÍfÓLcµZ͘d(ós#˜WZ>Ë›œ`àëÑhTÍfÓæ?Ìd¼#DÔ0Þ2ø?¯? ÚÕl´ûn”ÂúýþŽ&`ÅJ”ežudQLìüÜvˆØ—ë¥~òÛ~Rï}Ý{mâóq1,z6¡ŸþŽŸÖ{}ÞžÊn¼$c1pûJ²@_i³( ï’deŒ0ÄeH²™ŸCÏå£4X¼aK$ÙN D9íììÌJí‘HDårÙJŠ€a¾=àƒ¾öeEiËÁtår9+{ú¼@9ÿù€>ØP€ú->dzXŒúe#¬2.d€ } eÑx`r fX_Òˆú°dÚ|±EÞðhòG²fÐãy¶šk à‘ „B!c/1ÐÀ*‘ÀlÂr½hja•y¾y–”ßÑ)]\\(œÚîA¹V4\h0Ï|‹A‡k÷ ¶.ýëï1 Ù¸ô¦‹|>oÑT€ÍŸøÇ­&Æ6‡ïÇÉó]ÚjTK¥’Òé´7 xÁdƒ±#`y#žN§æð„Mö,²gS=hã=8bPJ2p ƒåüÜ/ -ãwÐzóæM‹E ݾ}[årÙØßÑhda×°±Œ žY.—S¯×³ãâ>ñ‰O˜IDÚºÛÙØqÎÐñ¡µ¥?póó‹ÅB¯zÕ«ô=ßó=’6åÿ?üÃ?4IÏ’wm#z@@Œ%ŸR©d,2Ï` à†uõc¹T*)™Lø¼{÷®})Ì—“Ø Ø{Îüʦƒ?7£YЮf `Ðî»±[§yg¥R1 »S­ByC’9üˆC@À¶är9[uùÊG4¿˜ëݾ[ó‹¹~çÅßÙ9fJ’ŪüÌc?£w¾úúÇ_þÇúØsÛ1Z òB{Êo'''ÚßßW¥R1F€ü3i pØs@;‹²¿_¯9„½Cß·\. 46èW1 §;P–TÃ8ð³<pÑ&QBbáÅáÊó¤$ Ããϲ•´cجyVѮٗ”a†`Ë…9"/o`Ü|¹’Ò%6Ÿ“Jô zDÀ7 `ËÖŃ@ž5à h‡5¦äIñçD"aì)%mJº9À"¬&f“T«Õ4Ìù Ȥ̉»xðÿ±÷¦A’^w™ï“Y¹ï{-½¨Õ­n¤V«­‘Œ¼2 ²°cF¶âFøÆaFßÇØ_|?Aûb‚0`ÂÆcÍ€!ì‹eÌ€qƒ-¬m$µÔ-«[­ªêª¬Ü+³rß߿N¶¹‹i&æŠÎ¡Ô]Ë›ï{ÞsžóüŸçùïîš\‚{ÊÁ€Ç;Â;À»É»Hd÷`Îû‹™PÃ3à}GƒW©TŒíçžS.çs'Å='ÇuÏòÍAÎÍôûýZYY±2*€Š’,Ï€ÏÈï”F³À‘gCŠås·›Ïd21@ìõz-o²Z­ó‡ùÂ… fêq݃}ß`00¯$Ù<;Úǹ-ñ`jùtÊÌ!ØÅ`0¸`ÿCÒ¢üŠýèGåñxô|Àþ¬ßïë}ï{Ÿr¹œ¢Ñ¨Þþö·ksssîûÖ××õ¶·½MÑhT¹\Nïÿûm‘ý~ ¶[^b“†µrËQü“H$ÌMÊFÃF(rû}8í¢±âÔÿ©'?¥_xP?÷Ïëݧßm‹1¥©`0¨ÿðêÿ ÷œy~÷ÉßÕƒ4‡åòò².ÀÀ Ñ5 u4Õòò²±"|6„¸š=b6`^Ü<<Âwa¦¢Ñ¨b±˜“$[ä“ɤ]7÷˜¿P¶Z-s²Â®ð{Üò°kñù|öÜM™çê‚QÊÓ„5³QÃ$Âd¹ìó`–H$ì÷”2¦Œ…Ȇ>‹¹äþ7Z4×ÄÏ•ÊïlÚ&Óß)ÙtD΄C³M8Žˆ㶨sC®aa¸xvlÌ”´)·v:mmmƒäOø7L,ì: - Ï”œ=˜TX9Jß”dÉ€dî"}à^à@¥$ÊÏb~ñÎÃÜÁØf³Y{ÓéTËËËŠÇãÖ¯—ËåæÂ¤)ñÃRíîîª×ëY—«W¯«Iy¶”ï-•JÖ¤sP³ÙT©T²{Íß‹E=óÌ3zâ‰'ôÔSOéÑGµõ–p ¨% šyÍÜ―ÍfçXhžËÖÖ–®\¹bÏsE×›H$¬DK!¿ßÿq+!ñx\KK³öo°ï0…î½!¤Àìff.Æ;3à<¾óïèSŸú”Ξ=;÷çøÀôgögzøá‡•ÍfõÁ~Po}ë[õøã›(úþûïW>Ÿ· Ôw¿ûÝšN§úÄ'>ñ}_Ì%NÈ,Ž®Æ Ѿ˴¹byʾ,Ô“ÉÄJbnÓw·çm.—Ó§Ÿú´†Ã¡¸ýM5Õgÿûg L¼ë¶wéÛÐCß}Hÿù»ÿÙ€ í@€T­VM»ˆóVÄÝÈa)5ZÑ€¹]¸&Äë0U”¾$YÎL× X’æ»<°øÂp°¹¹i¡Ñl>h°¸ï°Ük—áuŸ ?Û-·ÒÅ Ìut$`6`wÝH6GXRœ« 7ЙyåJq¸fù]DnHšk寽ÇÀàêùúý¾ÅÀx¼ûzFöz½^Õj53ÝÎ(?ÒV¬×ë™É‚hJê8–Ož<©ûî»Oû·«ÝÝ]]¼xQ‘HÄÚðƒAmooëĉ6O:Žòù¼8Ä\Ã‚Ü ¨^¯[ m÷ÿvuœ°V\€Ñ50ç …‚&xßyü~¿uA?G9šgÃ|­T*ö|™S89€íììhgggNçëõÎâp`i èqMçγÒ6ù˜Daì`¾ñóÑfroööö´¹¹©L&3gÂm SL œh"Ö· š@îu*•šcAyw]vºV«xo·ÛÊårs±TÄ3ä†{/Æ9ð:öööôÎw¾SŸþô§õ+¿ò+öç»»»úìg?«|P÷ÝwŸ$顇Ò‘#Gôõ¯]oyË[ôµ¯}MÏ=÷œ666´¶¶&Iúõ_ÿuýÌÏüŒ>ò‘(‘H|_×Böœ+˜wÛ±±¶Z-1®€™Í›$‘H̹×Ì…¹¯m£ôIy¦_|ñ‹GzïÙ÷ªßëëw¾ó;zÿë߯÷œy>óÌgô…ç¿`‹§[ö’æKž,¾”t {–4ç–•deFIÆòÁ6¹%U6b¯wÖÏ18_CÌ’ à26üsæŒtp·ò|¹¿0¬/ÌU¾‡÷s‡±L&c =Ï.s›ù-ÍÖ]mGwSºçpC©És™ŒÑb±(ŸÏg ¿+ñpó71…ð§Ói Ñægaá ˆ%‰Ì…°/Æ9ð:~á~A÷ß¿î»ï¾9øøãk8êÍo~³ýÙÚښΜ9£¿û»¿Ó[Þò}ë[ßÒ™3g üIÒ[Þòõû}=þøãú‘ù‘ðwrBf #á„áÄé)šS.ªT*¶°"‡-b!ÆÂ)¡[Ù… IDAT“³û;øùèÚ`8|þAù|>ýûñïõÀÙX è3Ï~F¼ñÇ$Ù¼Ñc¡%sóÜ|¦\âFÑP>L§Óöù`qƒÒ9„†öl ¡PHÕjU«««’faÕt]pMÜ#Êk0dÈávÍf³sÂxzÿ¢×sµ_.[&Í»µÑÁœ¸àæÅu4s_`7=±XÌ"\8  £´îºª%+ƒ®vU€1>+À›MËøàÙøèÏìÎI®Ëç›e>Æb1»Íf³©t$m׈vÀ?­ã *¥@I6ŸÜN-©TJ[[[æv?‘/Ÿüä'U­Vçæ% P‹2™LÚ{…ËgífR¢‡Æ¸»¥f€2em:mø|>Õjµ¹²ù|€2AkµšŽ9¢Édb ™¹Èa! éøñãê÷û*—ËöÙèJÃü'6'‘HÌuòyúé§5 ¬¿0‡âd`Ý™ÿÒKÆgœN§ÖºyÌ=wÝäKKKÖÕpV.—-ÆÕ)¦é¡Ì:[ÍgI¤DL\U·Ûµm(R©T2s“ëìbƒ‰‡qD»¸F¦ÍŸE a¼Àu],•ËåL àõz 4¸ÝR$8>ÙèaaNÝÖb€>;̤›a ÓE 6ÉÍe³Ù9Í.‡L$.+ˆöÌu$;$ðÞÀ‚òÌù~îY,S¡P°r5¥ÚÁ``¬´k:r"’T(äóù,*‰{ÙÁujS:†EÆœÉdT­VÕl65™Ìz!ã †‰ã¾ò9X©TÊXZ@'å^ ;Ng®a£Ñ°ÊÏ1‹©V«™óžŽ(™LÆÌȘ;h?€<;ä’æÞÖ*ÀèbÜØcay… ýâ/þ¢zè¡9]ÖÿÛ@ÓÃpÿûÿîk®þð‡-¬ywwW’¢H0eP¢•úޝÍnƒù`#gC¡‡+e,âÁ`Ð8Nº,æ­VË6˜¿Áx ÀR@?yò'%ɘX•P(d:(~‡»PJ²Î8›]}› ¤vww ˆ¬ÐÂÀdR6ïv»ÆrL&ëNÀæî‚?6  O„µ„©…1 œ†õÚ¬DæÜCŒ ”`—––”L&->E’™ Üû‡=„ŠÅböµ€L@úT™±XÌâm\³,¦˜Fî­kñb“ ‡V íÀŸM•^©¹\Θ1º'˜ Ûï³ð]î7}\‘ ¤Óic•é"‘N§ÍâÞÀ°[ÖlµZÊd2sÌ!¬€ˆ:”’a2Ý&yÃÀ¹¦·ï¦û>¸:LÞY´is77 ‡¨ååe9rÄ•ù{ØR€c,S>Ÿ·Öu¸Õ}>Ÿ¶··çž³×ëU¥R1Fc?ï?ﬢÇã1À¹½½=yS,õôÓO«ßïkggÇx,3÷<2Œ>D᪇Í#4ºR©Ì¹ma‰yï$Ù}…¥‡4lp:6ž–xétÚÖ[4‚nïsœÚ’T­V5U«Õ $¢‘d^-Æ=3à6üq•J%Ý}÷ÝögãñXó7£ßú­ßÒ#o9‹nÌ %z¿ß¯Ë—/«\.›´½g­V³\=âwˆ^¡4ëjs@â@Ñëõ $nnnZ ;Ÿ0ìþÊ»ÕjUÛÛÛv€¢t9ŠžcÇŽ™–tn_äjµjs‰ŸÍ»ÁZèj £Ñ¨ªÕª­°Í¬S€nÞ}֤Ÿ±Ç‚|…x<®3gÎÌýí~øóŸýÙŸÕ?øAe³Ye2}èCÒwÜa®à7¿ùÍ:}ú´Þõ®wéãÿ¸jµš>ô¡éç~îç¾o°¤9íY_~¿ßÀZX Ø«V«5×&Ëç›5‡çÄÏ¢–ŽÅŽÍ–¨ßïϘ¾ÓèóÏ^ðÂH’Åp|ñÅ/*ègnûM¦=øüƒæ`…Bj4Æš±1²Ð"ìG›%É%W¯F:ÁÁ` ­­-;ÝÃÄB‹ÛpiiIÍfs®3à‰ü2Wëã'òþjµšeˆÁ„s2 ºæ·‡1 ­Ó阀pC ì¡/Âý¤\æ2ؤ%ï‘§P(˜qÍž ó Ú'6aiÆ$ìð{aÏØ,€M7N¦0N+™L[IÌX.¿ß¯¥Á’e" À #ÉŒñxÜJº€nÔ¡%Ek¹³³#IæúuÍ n‹³ÕÕUlý~_ÊçóöNÂâòÞ ËhºesÊÐ8õÝC ÝYÌ_ò0ÝVkÓéT§ÓZ¯§ÆW¾¢Ñæ¦üÅ¢rûîßø?°vL= “Iùs9M ùÓiu÷Kš¬Ì/æm¯×ÓÉ“'åõzµ½½m²Øer&™»wpjµZ&]Éf³v8åÏ1÷°.R©hµZưràâÅýG²Á|“ºþp°sç %sÖSb¡8Üpÿºhaya¶aqˆ“ñÈw{ /Æ=ðŸáøßø ù|>½ãïP·ÛÕ›Þô&}þóŸŸc¾ò•¯èçþçõ†7¼AápX?õS?¥_ûµ_ûGý>ÄÆ,ˆh 9m’1'Ƀ)Q²›L&s}5s¹œ1„îFr{ŠÂ½çÎø#ê¦ÅÕ«}áù/(èßÝöïäõxõ_.ÿ‹/q™7Z…MÁÿ» ˆk@_»H®VØR²âr¹œ}æ@  #Gލ\.ÛFs@É”r4ì_¿ß·6v0XDU°É£Y !€çy¸íöâñ¸m¦n×´x™Lƺ´Àjñùam¯ ö…y`îQ:‹F£ŠÅgnÛD"¡ø$n.R® £ € ÄÛ%†ƒóÁÔ‘\í•[E˜ä>ã~I²€`m³Ù´ žÏç‚Læ®W®ƒ¿8q€q5‚€/‡$Ó× *”±]ý%¿F´^¯Ûç¦ Ø†ÕÆøãóù XRŽä~pí€Àtª×„B:ã÷ëÇ£ø£J>ªi0¨¥ÕUMOŸÖ0•’|>í¶ÛJ¤ÓªV«JF£êµZ´ZŠw»ò–JŠ\º¤øtª©Ç£A"¡A6«ÎM7i7›3 {”d±(0§®TðÌsív»Ç”aÏ}>Ÿ …‚j¸Oõz]ÑhTñxÜæ7Ï9•J«É‡8‡%æŒ[B. Öên0¨\.›ƒ½V«Ùõ æýãÏ:Ž2™Œ=7ÌPù|ÞÖ3×|†6ôìÙ³zì±Ç¬ò²7öXÀã¯ÿú¯çþ? éŸøÄÿc¨óÑ£Gõå/ùŸä÷Ã0L@K ²'š5Nº,Ö0g®H™Å½å¸D"aš–étªŸ8ñzàôú½çO]|ÈÊ+>ØÈý~¿¾øâ5™Lôî[ß-IúôSŸV£ÑP*•2‘9‹='k˜·çk,³ÏC ‘fºËd2iíd2i¥6*nIöýÏ)Û´ÐJJåbŸÏ§µµ5+yQf¦\µ··g`Ù½NÊÃl08 ÙÔùs_xV´“dŒd»Ý6]%Œ׈pHéò{s·i¦„L&cå;JtµZÍòå†"‘ˆÝ_4[èÖÜ–ka˜Ðv»=çÔÄãqU«Uë–€“·Ûíªë™Í½F£¡J¥b,eeÀš$ûsîs·ÛµÏ€[ÕÕБ!X¯×mž±"É4Ÿ°œ½ÍÍMëüP.—í³d³YI³’x½^W<>ãÝ`ƒÓ8ô\ a¬`"ù0û©Á@?‹é®@@>I›Š™Œ‚¯y¼‡ɛɨ³¸¤™9}ò¤Z½ž:Á ¦á°–Ғ׫õJe6ïS)µ._V¬Õ’¯\V´ZUüòe¥Âa5o¹EÛËËÒ~'€1LZŸÏ§r¹l†&î÷šƒ[µZU0´ùÏ3’dØcþØaÚAS;•ÍfU«Õì`ƒ‹÷ðáÃs¿“8™r¹<çþÆðÅzÇ+‹¦q…¡ÇÈÕl6•ÉdæÜ¥RÉ\Ø…$™®óüùó¶F17ãÆ ¸×= 0\ny 6‚|2Ôööö¬”ÈÂG¤ eBÊ0"äÔ±©½óÔ;õÞW½WŸ{îszèÂCs±,ÑhÔ°Â`0¨‡.>¤N·£÷ž}¯$éKë_²R3aº® ˜3bjØJ¾Æ-§0qÀ(À0x±XÌX Ì l,ÕjUÒlãÇã¶1³·ÛmÛ¤ƒn°½0i°&”â1 ¹Ù”›hÐèŒàÅd T.—ç\Õ0°ZW`adØtSé”’þ¤EfD½^¯9ÀÙ|Ñk. èlr¯yæ0o ˜£ÃáÐJ„0;<[wÀfbÄ`.ñ<¢Ñ¨E¹s!«R©X©°Â½„‰Ç6_¹FÀ‡%Ü7×ٌ۶ÎÕ3J²û!ôÛî÷û–‘xmX7&¦Ýn+ë´×«7†Ãº9Ws2ѹáPß]YÑÙ[oÕ¯}í,Ço?‡Gùòò²&“‰*•ŠÒé´jµšÅ«àdm¶Ûe³j-/k|óͺÔh(ÖjiåêUeÏŸWöüyÕWV4¸ãu=…ö`Z¶æ9ü¹©­VKkkkjµZÇJ$s%qd".»ŠÑƒm©Tš FÇã*•Jsf·«ÎcÖ+ähc}¾Y:²¢jŠËHGJÝTp€ó¬15qxðzgíëJ¥’ªÕªeR2ãÆ Èb\÷p;{¸ÿP uuflúnë0¾—¯s79Jc0xî©Wš£%ï’>wþsúÌSŸ16ÊírL&箕ßùùg?¯ß¿ðûòz¼H¥G4e×éØétÌí;Hk&À™ÛË–¸úûÂjÂöììì¨X,³ÆuÃ&PF¦”¨åçƒA‹:AsˆÆŽ ÖÝ߇F:0Q°aœpítA—è:1z‰ѷ¹Ñ/…{ì‚#¯×«ŠDô¿ÇãzW<®ñtª/´Ûú?:ý}(¤¥TJ§NÒwÞiZÊÇ´äkµZª×ëòûýæÄ& žƒ#9z¼cÞ¥% ½ð? ÿõ¿VãU¯R´^×ê#è¶o[Ó«WU¯×í@ÁçD1e'%€Q¯×íÃÂÁŒÿçP+ÉôÊ”ÄašI)@‹ K8™Læžc&“±ƒm2™ÔÊÊŠ±ÐÜçD"a‡'iî5sˆæ`½µµe:]æ&6ÖT4FïT#&ÅX0€‹qÝ]eS6€ ßÀâÄ"H$ìTNwâ.ÐÕNÐ:U«Uy<Ûøþðå?´Ò‹Ëܰà6ÐÖB¡¼ð µªsµa”YèÙøÉ1“ÚGñùІQ¶…½ƒEs#0Cpbgãà¹Þb±h¥&×@"É€,®CÙe¸$KH)Ï æk=DLtÈóù|Êf³ÚÞÞ¶)à²Z­ªÛí*—Ëx$WÑeaÍÐb%‰¹{ä–ÙÜV€°€<_ÚÜaHf¬óó:;׬8‚ÁغsÍp8T¯¿Ÿ[9Ùï ð,ñyo¾ùfF#=zTÍfS{{{­B™k#"G’¹â€u‡H$ºzõªéó%`F1ñodÐŽŒgÂçæß¼gîk%ÖûýºÅçÓcáÎõz*KšìÆT*¥×¼æ5:}ú´Nôš.#E¹ÐL$zùå—­4êñx´µµe€Ýëµìv»Ú8tHƒ\N¹Ý]-_¼¨ÓßùŽÊ'N¨•Éh8Z˜}³Ù4g4lºNÀ ó €Ç\ã€I¼œþKKKVf§•# šX$WÞÂA†Ã!kG±X4“J,3Yˆ{ˆ‚¥g] –;8U(T­VÅ•f,/ý “ɤ²Ù¬EÜЮ®ÛíªÑhü£ ‹ñÏk,ÀŸîA§yrå€2™Œ±:lL›Ù„Ýî’´µµ5ÇêPþsc*(›¹`þ¼NGNÇJºh°hÒ|Œ `ˆ×Ä4×µ‹6åi21ZP‚lP"¤t0"\V:p¥ÂK”~¯-²ÞyvlT0!€$e2é¼ÁÂÀþº×FC;;;Ö*¯ÓéÛ&ÉÀ)ì™i.KÁÏL&“fFqMXÊ›ˆð¹'ÌIä¯e$™nžŸ[Âw5U0=˜œø994Œ[[[j4ظ¯n»:À÷¶Œ`j6tîæH0¾È܈€ƒ Ê(™3‡=²Ùì\®Ý«½^½?VÎëÕï4úÃnW/íkM™ƒñx|Ž}†% V f‚ÅцcÇÁ‚{Ÿ…ÂaMOœÐwßðíÜz«ò—/ëð#(¹ÿîÀjSÖæÀÁ³çÀ …”Édæ‚ä î®T*ö>ðNG£Q ù¦íÞaŸï #Œ$‹¬‚ÉfŽsêóù¬|ŒK› ÍfSNÇÊóD>Áò³ñ^pŸX×××Õn·íä€Eg—Ÿ±Ç‚\Œë€—L&c Utg”çÐû rÆõHùÂÕç°0|ë¦ñSºóx<ÖÛR’>Ê]¸NÉ5¨¸Œ¿]ŽË°Šˆ|Y[[S£Ñ0ƒž`€{™ÿf3æZ0?©GyV”}Ïh4R©T²È•`0¨L&£ÍÍM>¿Â®bø Œ SÓCp1eD7îà ¸AìøN¥R&.§¥ÛÆ –wóh4ËÂK$öü˜3ÍfS“ðA¼%CX*Zbt §dF×âA(ýbÀ@ÌO©•Ò6Ï}&édâ‚•æe €!}‹Ãá°6ÊÔ„E£££4 øäspÏ¥y3YpÀ,,³-%YKAô ®Î–ù‚ ÓÏšx˜gqd8Ôÿ ê¿_ßî÷õõéTÓDB¾}öŒïÏçó:s挎=j@–R2ï>@¦ “Ëå´³³£xŸm$”ð(ß¹-÷*•Š$6òÒ`p ó9Æã±r¹œÅºaÇЮI2 ¡Ø‰D²üø nè. ’Ÿ-Éæ lm.—³Œ4$d^{½žªÕê\~/ìÞx ””(3ÁäÁ^à†­£¼êƇPÞtõZ–A¶_æÊsn”z$Yû$é w,@d:Úéñ4­²Ð Öj5Ó÷Ðæ 8‘3’æ²öX¨¯Õô öæZø½n>¦6|Ø57H›ØâRøœ”O)Ò=àÇ=¡lJÉæ®^¯ÛÆIy @ífñ`Tè«L§ B©yÞ8-Ýž½½^O¥Ji.°{È¡Üè(-//[~ ÛŽ’8‡Iä] €…M—¯å™r lÇ3a.ð @áþP*l4öl8d°aóLyælЮְbXh÷ »è–T³0F®ˆtàÕKKú_B!=;™è÷öÔÝû>ŸÏ(¯×«›o¾YÉdR§N2V™9Àà¶”ä÷•ËeÓ­Á¸ c陵‹÷<(˜xtÀñx\ÅbÑžƒßïWëŽ;tùèQ­þÝßé_<ý´ž¿ë.M÷ƒ˜%YŸ]IÖõ¤X,Ú{Ãûéóù¬o:6ÆŽu†÷a8œõØÅÜÁƒQ-•JÅÀ,‡NÓ]ÎT(i–]ýf8Öúúº™âÊå²2™ŒÉfø¹Ç hõz}Î ´7öXÀŸîÁ&`äÁ€\ëbdÑ#ËÇ!)›. Èëõ*‘HHÌîúýB)ÙPú$Kë ŒËï`Ó—f@€Î#8Xa©’ɤuŠ`1†£$0âºG£‘mhíè\ȃ @ïGÆ ?“MðÚH4CÍfÓ6u6KQ»ÝV¹\6„©€ëļB P],-À˜phX ×d2ÑÊÊŠÊ岕~a5(ƒA­¬¬Ì• iµ…n V·µëž†¡uYcîëàtþ1 ‹EsšO&+A†qæÙ²!ƒõÅíçsÙ¸)9c¿ÏÊ÷ÝnW™Ô,R%–ˆ) ¨šD|Xwß}·­-KKK:~ü¸ÅõT«UËÍëKÚú—ÿR+ÿí¿é¶§žÒKñ¸"Î!Š’w³Ù4憳³®“D"‹[B/ŠLÀek¹$¼3˜’úý¾ŠÅ¢Òé´²òù¼vvvLûÉïEâáê9Áš¢O}ùå— DÓåƒÒ¯›BÀ3»å–[Œ©\Œw,àbü“ ܹ”;P°”D9-Ã&õû}¥ÓiI²ü5W%«æ¦ìÓ—H ´n0w½^Ï¢S€2€H,S¥RQ&“1Qz·ÛµŸ KĦéfzž<i a!aÓ0H`¢=|>ŸivÜ B·4'Éý.+ǵÀÕj5cZ(_‘;&É@ÿM©·Óé˜& ]¦¿ßoL%€Ö5íð»íã8uY—F£a`’Ü<€LgÚQoÜÓ<óÿÇLÌ¢ÑuÕSÏzQ#5€…vvßnN¡û æk˜Û.ƒäv}à]Ã/K³|ºýÑÕ©S§ô«¿ú«v@ƒñN¥RjµZº+ÖÛ=:ë›ûæñx¬L&£üÁ´¾²LK\ƒ[¦N§òz<Ê4› ^¸ H£!ÿþ|™ø|êÅbšòúýšŒÇò ò·ZJ]¾,¤‰×«^,¦z2©ÚM7iº¯•¥½ßúúº666tøðacVŸ}öY “FÏ[ÚètÔºûnÝöØcºù[ßÒ ¯{ö$3˜¸nXò%Ý>FÞC45ög‹ö“ùt šŽm)Œo2™´%vÂ܉ÉòûýZYY1¶ÐmK‡kƒÉK/½dëàY’EH¡¨‡C]¹reCž);Íb,Æ÷9šÍ¦’ɤn»í6 @uurÒÐÞ‚€#úŘ( ½‚õ€ÙaÁ%@•(‘H$b¥×h4ªr¹l'sÊ ,~ˆã1P:J&“s-ã8Í-//kggÇÌ(DQ -"Ö6ËeÎ0“àÎD£Qíìì(šÎÇ J&¥V«Y°.`•x‡z½n¥pÀ1åA®'—Ë™ÐS å \ÇÝn×XT€L’û,óùü\LÅh4²øÊÑnð/åÊn·kíõ(ºeòè$ª˜/f%1´=Ë矱g¡`H·Þv«ú½¾¶¶·æÜ®§2Ýáè å¦Jåè¤zÝž¼K%¿d2©Ñp$ïÒ ôüuºí÷4 Œ)uõ].K0rÁ2ÅkKËDqm€væ*ï Œ.x˜27 Ðö ’$•JikkË®Ðéóù”óûõ¿y<ºäõê«Á ²¹œ¢Ñ¨î¼óNë.ÂïƒÉä}À…=ÌZ¦ÂaE/]RìâEZ-õ u–—5ÈdÔK¥T”/Ôï÷U­VM¶ðxh4m6å)•*—åUK§U\[ÓÞêªäñ(—Ë)›ÍjmmM‡Ò¥K—tñâEëÏŒ¹Ê•HHRt:Õñ¿ù #]yãUo4ì™ÑŽw) @ÅÍ`00°Ì;‰.“Ã$ò×le²‡}ùË:ÞÝ^èÒAgòEG£‘i›‰˜!r¨V«Ù*ÉØaÉùH$¢l6«jµª?øƒ?˜“Û,Æ5 àb\÷`“ìI²2 ìC,³ÒZµN§3DZ¸²Hâ>%[ †…r+b}7˜8jeeÅ:}D"U«ÕY¯Ñý…@%èuÜ("@ˆí`ãô±hã(FßãÆ¨„Ù )ûRn"¾6g4©Z­Ú½ä`¹V@0úJW·&´Õ$E‹€6Îu·òlÜpl6)˜SÜÑ„:c> ƒ2 i}}}.´Ûýœ0™L&•º%ígñ-½ú~„Åd<=ÏÛ”L&õ ?ñ *•JúÍßüM£0¯ñx\£ñHÃÆ …Æ!uº©+›CîA„̹Éd"…¤Î¨£Ö^KÙlVWwgzªP,¤X8f`¡T*)N›Q]ì2Þƒ^¯g-Ã\# s˜î®Ë½$ŽQ¤ <Üæ<'Ü˸)ýº:/œÞÃáPÿÆçSÏãÑ_Z][S>ŸW.—ÓáÇ t0píïìì˜×ï÷ËçñèØ•+Š?¯éd¢îÑ£*Þu—F««j9eî@«ezÐ|>o‡x<®©Ï§v$¢½dRíLFžñX‡šM¥.]Òéóç5¸tIÛgÎhZ(hwwWõz]ÅbQW®\±{…ö”ùã‰D´7é…S§tö™g”ºtI½Ã‡-1€÷ 3l=û‰9‡õ à U.—­dOÛÇ~¿oŽˆÅa-*•JÊårV!áݬ×ëÆŒ#¡; úÚjµjì!€9L±XT>Ÿ·.?Ö b¼‹NÇæÐbܸc㺇ˆ±‰år9cF`–|K2g/Æ L04”_Èps]ÆívÛJ(0…h®ÈæsS÷‰6aPæq™:Ê¢0Jné“ Ñ²áÔ^«Õ 0ÄÈ»£ 8sÝnÉÊÊq£Cؘ`â(¯:a"yǾ7‹Y *Ø@.ÿ&,–hÌ(n++IÊf³‘è\šé81ǰanaðy0¶œ«Õª‰é1Èû‰D´»»kŸíºüÇlìÏF’µùƒiyEwŠ!G:(cnoo[1·êòò²Í[I¶!¯®®Ú5’ÓÆ\ü¡‹XÔpòôÝù@)‡’ šP—U'ÀœyC»46}\ö‘HÄžóçµÁ nYZÒŸF"úÛo×ÚÚšâñ¸–——纆P¦—f:Ø|>¯Éd¢jµªöw¿«“.È×j©{çz)“QúÈMÉÑ#J3‹g€þ“ %ô^¯§d29ËhÜçZ­f‡:À“ËÆ•J¥¹ƒ¢{–f•C‡™ÎðÖ[oU©TR½^7³ =¥[Á`rxC …,O5kU|<77óbܸcQ^Œô |ÇwÌ1Q.ÓþŒr.àËe¾Üö1åóù¹2º8Ê<0|”òÜü<þŸMÚuÐJ²¯cSba„¥À ;Çâ ´)!´v|â` )¯ Îh¹wn¤…tП“Ò ìŸÝ–€I~¶Ë †(õ²°SVG¤ŽŸk€Ýä³`¤D¸Ùd02Ü;‚¯)sÃ,fܸ—Uív»ss€ïÇ,‹ÅtÏ=÷èÇüÇ•N§U©T´¹¹iωÒ;ÿÏÏ<±)ú†Ã¡Ž9b÷úµl ÚQZùÑùÍêÒÒ’²Ù¬•´ùŒÒA¸2â~WŸˆN+N C†pôèQIÛÌoæl·×뵌66`Ø,îï_ïv¡”îŠûÝLÆ@ `L—ÏçÓÊò²îm4´4™hç‡~HG·¹ KèæU^›qñz•ÿÚ×ÛÜTýŽ;Tºç•÷]Ì®I)‘H˜k2™å×­®®šÎÎáqƒ½ÉVŽÇcC! R)í?®p«¥#W®È3«•ÍZˆ3ó¦°_&F®‡ªíîÊèÖ.]Rs4Rc_‚€”,Shhy]ƯÙlZäË€s `þ¢Ý5Á=à.®ÕjÆ$K²÷²V«“»·ßƒ9ªÑhØ!Ö> Y´ ë%`’ßéÊ4X/\¸ øÃv\Œk,JÀ‹ñO2`2X|`8-³r &ë vŽ lhíü~¿‰˜&'t7”Ã`rø;—UL§Ó–Ûåf±aŒ˜N§–÷Ç&B÷ €$§w>  +˜Ó  è¥}÷ˆëçÚܨŸo–uç:£Ñ¨’ɤÅUH̉ t`çµ,O&ÓRš'W²Ï( À'Ÿ # $d86G0ùllâ_RSåry.ÔØÍ:ÄÝÊ5 ÓĘÀï}ík_« =ùä“ߺMIVå^bŠÜÆë2†{{{ZYY‘¤¹dÕZסPHÙlÖJÇ|mµZU¹\–$‹9"î£×ë0òz½öìéNÃÜrËÊ<ÌI°€óH$báÙ4ÐÚþ@§£Ì÷߯գGí^³ùKƒF½èþ¤QôOÿTKý¾jo»Ê>ŸûŒi¹\V4U*•R§ÓÑÅ‹­å óý…^0£L(ó SfIf¼öãwz=m¾æ5Š_¸ ÃÏ?/õzºrÛm’ÇcfŽz½n‡·L&£cÇŽiccC[[[³õ&VñÐ!ݲ¾®J2©A2i%~ŒSétÚZKrýÈYÉÜ+‘>ŸOÛÛÛ–M)iŽiF÷JÞ Œ«Õ²L¾ ‡C[§†Ã¡’ɤu}˜F#-//sF7›ÍÎu¤áG¯ÉÚÕ)ÃÊ.Æ;p1®{ 4–4ÇàQ B¿C“J¥æÄÛn(¯ë:esƒÊd2²(Åñó°d˜(w¤ÞcŠ`ããz^0ôµuÛ?¹:BX X+) ‹?6¬š4;Ýg2™¹r$,Fò~¿?î̽ ü£P`$“I;ùƒAz‚»¿l`Üî÷3ú*´ZîæŒîq<>è7 +CIyccCçÎÓÙ³gU­VõÍo~SNG¥RÉ€†[VÙéš)xv<“f³©n·;÷ìÚí¶âñ¸Âá° è…ôR¥G æ"Lj:V.—3ÖD’VVV,À  á@áþ9×ÑívuêÔ)Ë’¬T*&ÀL°²²¢V«e¿Ÿ2= šKX×@ `!Ô8½]°‡ó&.“É(Ljõ«_UûÄ yNœÐd?–6P³MŸ¥¥%%žüe©ß×Ö›Þ¤¥LFþýÏàjBam]-0ÀŽ-¡àTöööÌÙJÎ%Ñ8ÕZMãS§ä ‡µöÄ{<Ú¸õVcø9=zTo|ãuîÜ9U«U3žôOR¶ZÕÍÛÛún<®T*¥b±¨Á``kåVIÄYgÜuŒçËÚƒìç„Æ¶Z­ZÅGx¿ß7‡?q->)iK²çŠéƒ“4Ëæ¬×ëšL&ªT*6gyn|r’P(d†'ä.‹qc\Œë”˜0L¸ e63N¸|›'(aF`±Åí늡9É6›MÛôØŒ)¯Õjµ¹¸Jj”)ÙüY,Óé´•N)wR²ág`Òè¦R)+SJd¡ÇÌ€€ŸØÅõ Pã{Ùx`RÉ‹F£Öc”Èœf³i›-º=6C6?L™LÆÀŒ[žæžó»)³á *gs¢´Ùét,¯ 0ϵp`~øá‡U­V 4§Óé9v~·”àâñ¸Z­™+—²¥É¿ÿû¿·Ž”N)‹³™ã†„ÝáÙàvÀ÷z=åóy3$¸Ú¿d2i ¥ßï«Ýn›¾‘ŽÌ9b‹ØØ …‚eÿÁ¬±i/--+ 6ç`Œè§ CÊ=Ëçós†!´~<›v»màv6¹µ%_¯§î=÷Ø;‹dã&üN§£T<®Ø—¿,o»­â›ß¬Êd¢CŽÁ†2,s‚gJvŸÏçS£Ñ°®µZÍô¼“0©èlq03‡¸Ÿt·)¯®jtûíºéüy)Ö3©”r¹œªÕªŽ=ªÁ` ÍÍMýå_þ¥Ö××­l_©T”H$´½¶¦CW®¨|ö¬­QÈ ˜¯®´03Ìý£ß.s Í(`2*‹©\.k<ϙÈ.â"5á¹2g‘†ðgÈPø^ÞQÊëÝn×ÊÓŠH%ðïg=ºkÎbÜØcãºn\Nÿ°~”dÝvZ¥RiN(N±« Boƒ°…Ö V`Ç)™Í óÌ‹Ýp8´þŸè¨ÐZQbÆ@€F…šÍ·R©XYæŽìB>?@À ¨,¡¿£Ü ƒÉ5½ ãôžJ¥lc`ÓD/èóùÌ|âÆò¸¥C ·ƒ ¿–v\–’LÀ™ ì¬c>Ÿ·ëu»D¸F˜^¯§ .Xë0>;ìYf®9…kÀ6›M+¯öûý9ó€n<žuè4–ŒI‡g_,í># * ös:d ¸ÕjiyyÙä€jµjs Ë3puyõzÝb<ÐÈÁ8Q†§dNi ‹€ŸŽ€€T«Õ2:‰˜˜ë<÷œz…‚v&Åö3)WWW5MOJçJùÓéTÑ'ž¯RQóÇ~LÃHDY¯W[[[öy4n‰qgggN+êŽ …‚’ɤ®^½:÷þ3§y`u™{ápØæ`§ÓÑK©”§NiåâE-ß}·:ûºÎV«¥y<ѬO¬Í›oÖá—^RfsS/ï¯M®«Z­Z’jµjìœ ÜªÎïíí)“ÉÌ>‡C‹Ecq‘¶pðºçž{Ôl6µ½½­jµjÎhIQD7€Ÿ$ë³»»«T*e/â‰(ÿû|>­­­éÎ;ïÔ_ýÕ_«\,uìØ1«,Æ;¼ÿ³/`1þy Ê8”b%’¬Eæ´Z”!èi #ɾŸS5¬ €PåN§£z½n`‚²ÖÒÒ’vww ìðõhc(§âî£lcÆu ‡C;Qûý~ ;IW*Å÷ËH8aî ›S< <ŸM‘òåO²C9Úí] @u˸ËËËŠD"f6ìÒm Ä3àsbÖ¬º÷ÑhdL#Œ,ŒàžÒ5%J$Œ(˜$Ânv"ì1Ÿ {ʵÓ%•J™i‚~´cîS·ÛU¥R± jîS¯×3V’‰âUüÜ@  ••3E"% c ‰Ül R&GkÊ\À ÁI¥R:tèÖÖÖ,[kÉçóÊd2:zô¨µôJ$Z^^6À #€Ô ›N$j4nm)\.«vü¸éF€¶¶¶ì~¹ì±Ï7ËÈ‹5›J=ÿ¼öî¼SÝýr€o/Ê•€Œ'¸íÝûÎŽç³Å3ÇéN(69 kî½÷^Ýwß}6Ç^>|X­XL§.\Phî4 E"u»]›C>yFLFÕ|^Ë››êíGGaºè÷û:v옔ȫäpGì ï'ì)úKI¦ÁCK°FÖÛ;‰¨ÑhX>"Æ‘k¦$áëtß æ7 Ó}>£ÑHÅbQÅbÑÞ'JÜt!YŒw,àb\÷ @Ö¥Ñhóƒ!Âm•Kæºzp°€‚d2iÑÒA—I6lB€ 6IV¢cC¦4çñx¬$ j·ÛvªwC‘Ñ6â(=|ø°B¡*•Š9b—U£,Ìç`Sãóú$™ ÓÿD»$ºŒ FwóÛ(k¡£ƒ!âZØLÒé´|>Ÿ677MåçŒh_…Y½'NMîF4eÒŒuËf³¶i»™{€ÊkE»­Ó(ir/)sV«Õ¹b¿ß7†ÎÌ ~'ójggÇJüÒÁ¦½»»k€Ÿˆ×ÈBiÏez|?-¥°^YYÑòò²²Ù¬âñ¸²Ù¬’ɤÝ %ápXápX•JE“ÉDÅbÑ)ô­å粹ø×ëu»‡˜(/Ÿ}V“pX‘;ï4`ŽD‚{ŽÎØg¿_©sç4Ìd´yô¨:Žéâ0©ðÞ6›M‹^¢|ÇU*• Xɽ„™n4ŽÎß„9ÄíîîªÝnÛ×rx‘Ç£â=÷Èßíêð‹/š1v[’=«étj&ªv»­æÉ“ ìíéæ}h$ÑÚ~ 6Ÿ¡Õj™D€f˜@î¹£ÄÚ`b“dÚLt¡äúñlž|òIÕëu fÆ`”L&µ¾¾n€ž ƒV™¼7¬y”ª© ‹E=öØc¶rØ .Æ=p1®{Äb±9­¥´SÉdÒÌ z—jµj'mLœ¸aªpk£+…™÷«ƒ"É6V7˜Øe*ù;J@èèNâ2aFÃÊS4XgñfÇÁ WÐu÷¢5”4×C–’$à“ó{&“Y?TŒ¸%YÎådØMJáhÃb±˜ \¢hŽpbg³Y»NôXü|,! ”4 ‰vÝÇ×Ñ£Gíkp(»@ƒR&÷Ÿ9³‘R¥S:ÉH² Ý(Fʉ€X€.YÂÒÒ’ ûíɈL!Bê²Ä0€l€ Ý `BÝŒAWÛè’sáyóç”ÃyŸÜ®8€O2‰Ûét:zùå—5ÌÚ"RÖ³Ž"­–ÒW¯ªyâ„JûÏ€†yÀ»%I‘ÇW`oO;÷Ü£È~¨¸ë Æ)ïõzµ²²båçx<®f³©v»­'NH’…óy%™™çl"‘0P`ÄÌã÷ûuåÊ;wN/^´9?Õ…´yâ„2/¾¨UGÓËú€n‰ ,w3‘P7WúòeÓÐÂHÒÙð6­ƒ 량C¿“wÇ•Z ‹¦•âh42ÀX#íÀírÄÜN$¦mÆÑ¾´´¤r¹l%åv»m%ëñxËóÏË;«wÛmZ^^6ðÊüäþ¡5ëv»ê7›J\¼¨Þ«^¥á¾c¿T*™%|ÚáñoÀ ì ë6ÞÝݵÎ3’¬´I¯lÖKôø®V«*‹ªV«öîÒ)¥yÛmêÆbÊ^¸`’ ¤nø;²ˆh4ªñd¢ÒáÃJ—ËJï¦8<Ĺ:¨Ôëu3ýÎΚÁÚƒóÚ=tHš«DÄãñ¹Àqä'ô5FBuvÔ-ᛣî!…÷‘u‰ŸÝjµŒ)†¹^ô€XŒ… d1®{XPl$¢b±h7L À‚M‚fé€N§èWÜöU’Ì Ç"Gy3•JKÅ&ˆÐ™r’Ë(°ñ^îËEé8‹™Y€FYˆ´ëÂdc¦ú¦ku…’ìpµrÝ€`4’|›ÿOF_8ÖÞÞžr¹œ‰ÎÑhábæsH¦Ó©†VWWÍÉêjæ]™LÆB“WWWmC•d¡ÕÃáP©TÊJÿïxÇ;ôÃ?üÃòù|ºõÖ[U(ôÛ¿ýÛvï(GòŒ[­–ý7%W7/pNG@†¾¦–½™Û}‚g;S:ÐBª™#ÑhtN‡*É´è49 »Â¼¬ÕjÊd2ÆbüH§ÓÖŽùÀa(ŸÏ›†ó ìŒ3ì6À‰î¼W°zÝnW·Ür‹1ÓÃáPñjUtZJ$täÈÇc­¯¯CËÁÇt¿ßWô»ß•gèâ!DKmooÛ÷…ÃauŽ“çùçÕ~þyï¼Ó%ÉdRõzÝÀl»Ý66C]f_‰±Ð~èÐ!“<ìîîÚ÷óŽI2ç:ºW7¬Ýï÷«\.+‘H˜œ€÷'úp8T§ÓÑÊÊŠ¹¤ƒÁ Lª®‰Šlo>Ÿ·CÕbܸcÁ.Æut*Dmär9+ÙòÊBà“dñ-”ê`/\Ö©Ùl8r5J©TÊ6B€ 2Îc’°qƒÂöÀªär9+»rrXÀ¢ÌL&Û `„ŒåZˆG¡¼‡íôN ‰ßåj%ëÄF(àç=ãv!*– –F’•·É(£ü,ÉX€äµAÓW®\1Ñ'+++ZYYQ¡PЩS§t×]wY E2™T>Ÿ×éÓ§•Ëåìç¹ÌÁÍt3˜Nú?cZ!¤öw-›,¥ r)5éêëŒV¶•Ív—Ÿ µººjZÀjµªV«¥n·kÚ.~žË2u»] îu 10Y€%>ÓÕ«W­4IŒ›/P@i‚{Ç\aŽ£™£¬Õ4Ø$/½ô’úýþœ>Žë§Å”{ùeuŽQm84°FçrúÜœÍp8¬|>oÓÌ<׆¦š¹ˆ© ¨ŒÕëuÓÒÑKš÷w:ª¾ºªÑÒ’2/¿<Gäf¦ÓicÅ[­–*í¶zá°V$û\Á`Pëëëv³¾¹9’ŒQóz½Æró.s2™ŒP>3 1n£••3öpï†T«U[Ëå²IP`oùZ˜s×­= ´³³c€{½ p1®{°ps¢§ŒžÉÕ©1;…BÁ"X({˜Á¢¹àS,ôwÃáPõzÝ6|˜²³\sÇh4ÒÚÚš±k008ƒÁ\ÙWm§Ó±pcØ–PÒA)›²’àüJó‚^ÑQÂVRÒ„±ãQnÃe ئ ÍF%É:¡±ó>|X£ÑH•JEõz}®Öh42F‘Í­€mccCwÝu—n¿ývÓ&}ùË_ÖÓO?m`„R«$‹Åïér€&öñ¥—^R¡P0ÓÀ &”¸ž)¬ %{Jé^¯WÉdRý~ß2)Ù¸ÙÃáP—.]²r®ËVJ² b—ÑCÿé:`i9çn n·ky~’¬¬Èœe>2|>ŸvvvLwF˜:ËuŒÃO;Úm•’I÷ãüL €"|’†ͦÊwÝe%b´‡ ¯­­Í•ÑÍÁPñ~ÂØÁ–JR¹\¶¬DI–ýèuƒ´™{¬1nF ÞÙI  ú‘#Ê_½ªÚí·k¸ï6ç†Ìo4še‹öR)…öM™LÆ´‘D馃Ó‰Åp8T¥R±¹ ÛÈ{ɼáгî†És˜ 3 îkÖ<Þwþ±¢St»‹¸ÿ`äHîç±cÇl-s%‹qcޏ×=(¥ÁäOáK§l6gŸÏg}0ÉüB¸H$”L&•J¥ÌùÊ‚Õn·µ½½-IfÎÀÊâËÂwûí]ýÆo<­cÇ*¶Ñ¤R)s–r­J…0F0nèÓÐ'bFpèýø¬|FÊßbSÂqªœÞ¯,Þ®)„..˜ážSVìõzÖ€²6›‰³B>¬Qn˜,×Û7PÖ„©ÂhP¯×õÈ#èÒ¥KªV«úÒ—¾¤_|Ñ>Ÿð†Ó6Œn»»»ªÕj‡ÅÁý†9”:Nø|>+Gr/Ü. Ü;ÐHø\ÍfSNÇ@<îH¢ÜïuÆt:m†%׬‚¹B’s¿ùsÞ˜/´_ÜïR©¤J¥br b®‡r6s€ÃœÅl2Øwyîíç rɸÄF•Ëåf`ëé§5ˆÇÕÎå”Éd ¸QO¥RªÕjR&“‰|ÀÒtw8OÇ㱉„I8(­¶Z-cAÑÛñýèaÚéRƒ–û7NU>rD¾Á@žË—Õh4äñx”Íf­lÍ{É= *y½Š´ZŠ„Ãj·ÛfFɄ٨º†,$.äTòήB¡VWWU¯×Õl6U¯×9åðÆ}äÀJyÙ‡t‡êf]r˜ô!?!k{–Ïçí ÇÇ:¼7îXÀŸîÁ P`žN§* ¦‹‚1aa•d+Âvrîè—ËFE< œD"aÎSœ·®¿ÿWÿj]¯~uS?ò#WMF›+úÛF£QcPpæáH$»Íe2]—×+É6ût:­Ã‡Ëçó)—˰t7¿ßo ú®F£¡D"a.d6Ã|>6Q·×2LÊq’Lc …Œ%%–ciiI—.]R½^W½^· d~7ñl¼läˆÈénñÜsÏéãÿ¸þÓúOúÆ7¾as€„Ñhd®F´”iéØ;EN ÈuY\]3º<ØÀ`0h¥àétj=}É¡k6›Êår3ƒ˜N§ ˜¡KåPAŸÏ3U(ìy§R)3½³®.°~ZŸ19t¸1F°Æ”©y?; Íì÷ûº|ù²}fÀ*À:+ÒljìóikccÃæJ¹\6ƒÅè&ãͦ:…‚û÷Јâ°åš™˜‡°s0R0Ò8¤p½n–"™šÌ_Jÿ>ŸÏ¢ŠX/Úí¶666 ÐÚ= 4…”Ûÿü’ì°BI˜JºQ¡ ßx¬é~ø3/î|CzÐh4ì}&ÿ“kânXóp»K²Œ<‡G¤€ü\.ge|Ò `RY˜ƒ£ÑHW®\1f¿$ÓS\óÌad³Ùìÿð½a1þÿ=p1®{ ÷µB¸ø(C¢ƒ¢¤Ã†ÎæHTš'Äí.ÛE¨*L uÿóG´ŠÇ3Õ›ß<[Ðï¿¿¥T*a?—M‹ ”ë J²žÃ”ä”baeßâå$£kó†Ù ²`°Éºe(·묔4§IkµZªT*ÚÚÚš‹RA7°fP* …B¶q+ÇïLR‚G£FÿVÜ«ãñXårÙ6?€$ì+Ÿ‹ø5î'åZÜá\›$;0’ɤ,¶aÝHb±hà‡:¿-àÊ2椹~·«•d]`._¾¬b±hÝQ˜G”œWWWí~N¤†˜î*”¦€Úí¶ŠÅ¢Í'X€;%gbGâñ¸ …‚*•ÊìÞ×ë¤ÓŠìƒ0Àn"‘°Ø [[[ò ‡ò·Zòìçá¹%ÊÅ”ÈÉã>#«àaÌb~¹ œ[òoµZZ]]5ã8— ä~Á~†Ãa c«iG···§v"¡È~?]>ó÷ݨ$5ö¯+P­Î9ûiGG 6Þä°h¬Oè39„ñnÍfÓzó.»s`F™™{Ž”ßÃup8qjXyî!÷`ÌAi1nì±€¯ÀñÉO~RgÏžµ|¨×½îuúó?ÿsûû~¿¯÷½ï}Åñö·¿]›››s?c}}]o{ÛÛ¬üóþ÷¿nsý~›+ @æ?7£vƒ“/¬ Ì«c¡¤ÁfkÖét,Ø•H À&¬ÊþàP™Ìì²Ù‘n¾¹h?›R¥B˜96(€,–ëþ¥ÜKÙNšéøQÝn÷{J½(JEl’n†¥dXÀ_K6ëd†áËf³æ˜EGãó¹ù_€'60À%?ʳL¸®¦’Í—ò7÷Wr»ÝV½^7ñ?ŽñF£¡r¹lÌ£$ãôvvKÀ®‰ •J©X,Z3÷9ÁžÀ2ã0Ìñ{pµJ3]"Ç£b±h™q&Isf(õ…Ãae³Ù¹Þ˘(ñK2@Až#íà`l]í¬Ë®˜°Ÿ\?ÕZ­¦R©¤\.7Fõºv÷Ù=ä ÌaæÔx€=yZÒcS¶¾¾n›Š¤9A9› ƒHõ0NlŒ8ÝܲM»ÝÖþhCkG#~臶ÍPÀbì²”€;X%NÛDÍÀ ¸:´I”µÜ kþ³‘øfn$ÑÕ«Wmq†…sYEòé®8áwpŸa2¯e]}>Ÿ¢Ñ¨2™Œ•·]§£$:tH+++Æz‹Ã š…Öh.P'fãÊ•+öŒ`Ùëõº:ŽE¢Äb1cßX€€(ÏVÐév{á>ÇÎÎŽe"Þ§„ 8¥¬×l6 ˆ»ù~…BAÇ·{ ¤|†Ž–ŽïåYÀ¶t»]•J%U÷&·[C§ÓÑÎÎŽbÀb2™´|AÌC8va=]&Úe3™ÌŒ‰µÔjiº`ê÷ûj4vÍÌБHDÁZMÓ¥%Òiíìì˜æ”w}&×? T«Õ´³³£¥¥%3Vñ™yÆã±¶··írKöÈУ…ã!ÿ. ªR©ÌøN§£ÍÍMËWFê¥ÓòF”JÆÀ±Vìíí饗^20±‰(¸Ï´c:©=zô¨|`Äü9ól}}ÝÞLaÉdR…BÁ:ê`rqÙ7× ÍÁ“h¡¦è&‚>”ùâj¥]Í/ï-ó˜9J¨ûbÜØcá~Ž·½ímsÿÿ‘|DŸüä'õío[‡Ög?ûY=øàƒºï¾û$I=ôŽù¿Ø{³X9¯ûÊwÕ\ujžÏ@qÔ@Q’ɆeFÅû!ý×iÇ2Ç@nûÅ .à~ì N†¼å"AŽ;A"ÄÎà!íĆ!å&Ñ@›¢DQ¤Hž¹æùÔ\÷áÔïvÑNºc5ÐPX $’‡ç|õ}ûÛ{íõ_kýOêïþîïôôÓOëë_ÿº®\¹¢­­-­¯¯K’~÷wWûØÇô[¿õ[ñ¿:Ø8i²á»ú4ŒäÿB`'hwÄBÈ¢•H$§qLl"ÅâX'O±‘Ð÷¾wO࿦§Ÿ®ë™gÊók>*Ãìï÷Ôj—šha½``àúý¾r¹œ`F£‘ÅSÀ*¹ZÇX,fŸ‰~§h =éþÈwK&“ÖŽ*›ÍÚæç†£Ý½J9\:v#ŽF#ÓºS@".[ŸÏ§ÝÝ]ËöƒÙãï\<«X,fÚBJ¬n;7·¼…^ V‡MàŒf–ƒæ@ ÐÁÁÁkFì (!ÐÜ@$-¿2™Œ1Êw|6¾ëÈ„Q‚ C ˆ ƒ  äÊ`†ÑÃÌVVVT«Õl¾u:còp¹ò¬\sÆ–N§cV"~ÆÃ¡<’|sVŠà¼P(˜yƒûîv5ˆÇÕêttòäIÌ0ø°RhÔø¬|¦r¹¬t:­½½={ÏŒ°°’¬óL©Y‚)+ )›ÍšÁƒ n‚š1á¨çëpx¨Ãù;H•ïIV(lóX’þ<+•Šf³™ÔÜ÷³ ,.óƒy£àæ>W§è[‘?Ђ&™¶EK²ù‚3_:®8P’w]ï€Rî%¬¶$c/— àrHKø–“ÉDög¦n·«Ç\Ï?ÿ¼F£‘žzê)ûšõõu]¼xQÏ>û¬ž~úi=÷Üsºxñ¢?Izúé§5 ôüóÏë‰'žøw]L›"›?´þJ«.²çÒé´45,t°TD7H²S=›âýßùõÈ#­…ëº3è>ëOÿôúŸ½ôRR¿ò+˜v‡#%J¿ßoíª\ÝìÚ%· J99•J©ÕjYÉ& mÿÖm./kòÜX Ø6>;à9 …T­VíëõzòûýVÊ¥ìÎ}ìt:Êçó’´ ÉÜÝݵ͉R¥)À /`=)…ãL„¥äJ›½ù=Ÿ‡r›+sÌÐ…B–ËFm3m·Û³Sìê9q¿Â8W«UR7·¬Íf KCk®^¯g¥\wÞ¸:3L&Œp8lm눶I¥R¦OŽZ¥R)íííãìõzU©T¬äL?åd2ièííme³Y͸o“‰†s¶ U­V ÐX½“‰FsÍs@[èv§tQj ÚÚÚRgOœ8a'®†½ï:¥VòAÝ<=À–tÜ-$/h+iÏÆ}ðz½ Ìó½sí¢¤…÷†÷‹òíd2‘7ÔlÞ‰d8*“ÉØ{‚–C¯×3³F0´ðe‚TF£‘Òé´Å[¡÷åð üQáSÑÀ‚Á„k'6i½×Oœ8aÚL4±È!$Ùý»sýXŽ»w,KÀoÑñ½ï}Ïôr¿üË¿¬gžyF.\Ðþþ¾"w‹EíïïK:Ò;‹Å…¿GxÎ×ü 1 ,´•_ X6bØÙk¸çØdp‘2¦Ó©raf܈I å_´Gù—y Í÷=IÒ/üÀßO§Ò`àÑ3Ϥ¤lB¸òpŽJ²°VWSV«Õ ¸"a<Ù´?”g1»%è:û`„Ø(‰}`1w™X=Œ'01°8YÑÜáP%fÇíBü„«Yƒ}…uAI°.‚rî •.#”úÜè·ëJ­V³R1¬ˆ$lˆ®`Æ’Í‘ùrgOåd2iåzþ0‡9ùL¦L %ç`0¸ÀÖ2OÜ,F®‘Pç¶ûƒ!u¥t9á^³aw»]u»Ý…¸Ê~h̒ɤnÞ¼i?@Nq£ÑP{îfί¯Ñh¨Z­b^‹E3“L†Cùç@ C‡‹f³i›¾@àÀ ‹Q¥Ñhسpÿ‡-:EÇcn\‚Þióç>îà¼Ñh¨ó¬ÅÎ"°kA䇇‡jÊ7×ÌbüBcŒI…CÏëAgËõ°>Ñîù8™L”Ífµ¶¶f€”~½n¥„H˜nî¡èˆS©”IA2™ŒÖÖÖækœÇ™°’Q£ËDb±,/ǾEÇ}÷ݧ—^zIÿøÿ¨_ù•_ÑG?úQ]¹rå_ýzJ­ Ïèè|Íã3ŸùŒÅw$“Iõ笖w>O8ôøý~kçGõ€H™Ï'Íßs¾_"‘0† ÖF$U4U2™46_Ûï÷µ±±¡~¿¯_|ÑîÍ7ôµ¯}Ͷ°íHxÿp9ãäusk4™L”Éd”N§ížT«U{VðøÛÛÛvÿh‡¸wïXÀÿ wè£>ª@  o|ãöw{{{º|ù²ÞýîwK’üq]¾|ÙºiHÒ׿þu…B!=úè£ÿêÏ@wåþ’d'Z˜é8— Q; …ÍÆò! ÃçóYÉS’ L´4°s0&€ÇnWúÞ÷Ò ¥`wL§Ò /Ä5™„lw]r”]iKÅgèv»ªT** ös f±‡Ã[C,ßÏýŒlL€Bþ‹é‚MÖF™f¸ ù”áèY ¨…]¡tèñxLGçÆnŒÇc•Ëe•Ëe°vJù’ìgâXŘ{›w €Ãq ð‡I“d%0„òSFJ£3ÊÊ€ZJÓ…BÁœ¶Ü'ZÅb1»€ùH$b¹Û³uooOÉdR›››Ö/‰ †!‡ÞÍ0¥Ä®`, Dˆå3íííÙ\¢´Hžf.—S±X4Cˆ$cÙÝkb3ǽ:œ¿ƒùÁ‰ûP«Õ ˆ1¿‘t&yç9†0™hÑ|rãÀÀÁ6°ÙlÚ\ÔXqÆÂôÓù Æ>–>Ì*™„Ì/æ‡(Ç£(:Ñ9CÉû8›Í¬sFžát8Ôlþy` S©”†é@é®ÃßqÈFK)ÉŒ,ÈÐòÁ–¶Ûíã rÇtz¬Ÿ„Kóµw–m9 ’ÊÇ>FLz÷ÜsÏBEc9îî±4¼ÇoüÆoè'ò'uòäIµÛm}éK_Ò?üÃ?è«_ýª’ɤ~îç~NŸøÄ'”Íf•ÉdôÉO~R=ô¹‚Ÿzê)]¸pAùÈGô;¿ó;ªÕjúä'?©_ø…_øw;€¥c§' 9Ì¥6Äò8V¥ã ¿g1f„ãzØdùwDÀe¡~¿¯ûïïj2‘¼Þ#Àwçzh¨ÿöߎR\ŸÄ Û Q^b!fq¦ÃáPFÀ«d#¡£Ô …´¿¿oº6Ø=I¶‘±QºZ<Ü´ûB$ï¶Ó¢+e6Œ)lŒ´¡âzêõºÖÖÖ¬LŠÑæÂueê€X7N¦ÓéØfíš ø¬lX”ÆÈŒ“dš(:™À27›Mcž™'h½ƒõÍÇj4ÚÜÜÔl6S&“±‡OÊã—.]R±X´Ò3nMJá®KÖeÊÐ#ÂjRB%˜÷À±¿¿ošÞÉd¢T*¥jµªáp¨¿ÿû¿×p84P† 5›ÍZ¨o¿ß· áÁ`p4|>…æ%@4óö¹×ë)™LEÉ„ÃZ=<”2QkÎFÀjµš™f0%ñw<#¤ |2+•ŠÉ,~øa…B!½òÊ+öµ†ÜÞágÁhÇã*Í#^°®t:æÉùYú IDAT“’Ç£éÜÉÍáЀÆ!ë4˜ԢѨ>X»8t ¯ø"ùpç;ì^¯gåmÜè?Þ1Ú¹!éÍfS¹\NßûÞ÷Lƒ +X­V-Hš²±$“k°Nðx7ù^¯WÕyǓӧOS¸wïXÀ·à888ÐG>òc)~øa}õ«_ÕûÞ÷>IÒïýÞïÉï÷ëƒü õä“OêÿðâIþú¯ÿZ¿ú«¿ª÷¼ç=ŠD"úð‡?¬Ï}îs?Ôõ¸Ì¢pDÓ”Np9Ât…ÃaU*;SúE—$ÉÀú¹ýý}+¹¸~èÙÌ/\h+Æci2ñèÏþ,¯Ÿþé²|¾™ü~éüùªB¡µ…`gôsüPKùÊ·$´iœüYxÉUQjbóÇãVx MÂ4 ÉÚÔu»]cÒn@2àŽƒÆÐÕL’+;!É@l0´÷^¯×´\õz}¡|Ï3(KZ`R¥ã¾ÃCø’´y\˜Ré8œšïÁÏ… Ä9ˆ ëB¾Ÿ«Ýƒ½D“È÷@¸.l$˜fРá2Ez[#i!Gòĉ’d ð@Ol@+ºVJçÌ/Œ+++*•J¦ÿ¤Ãß ½$Ÿ“{Ä‚H?“¯R‘çÌ+ÓRVM¥RÆì•J¥#'ñÚšôÚkJöûêÏŸåw@7 Y†Î< tÊûO)Òï÷ë]ïz—Òé´éÓ¸‡hÑAòÞIG †lL÷gÂ.rÿB¡Rý¾Æ±˜üs éV$©Z­*—ËIÒÑ«ßW¬×SïÔ)k_ù¶·½Mׯ_×þþþBä\7ËùœÉè™Çs“ŽäÈÚí¶ …‚€™å˜7qבN™žx)Ö×Ù‹CœŠ‡ÊßÈå¸{ǾÇüÁü›‡õ…/|A_øÂþÕ¯ÙÜÜÔ_ýÕ_ýo¹6b„̔פãDöNÇÚ°QR‰Ç㦃M /[ÿ_—mâçN§ScŽÊ§‡:}úèï··Ãúµ_ÛÐoDôçžÒý¯7uúôPgÎ úÔhôlSw™—dã °áÂİ¡¢³»3.… ”òo<7@‡É¢×ë-0tívÛÊT” aŸè:„eàçdù\l¬”ÖÈL|žöz=kE„ì` vàㆨœg͆Ëæ˜Dª€-˜$²Ó˜;;;Ö°ÄF ³ ÈÂáIÙŒÒ7îcærW§ˆ®¬X,ZÇ’f³©^¯§t:½`¡Lí2Œëëë¦oDëKÇýcpHâ9>aÊõW"EºÝ®u¨×ëŠÅbÆV»l–û:ñ¸sí'‡Ü»YŸÏ'ÿêª&^¯|¥’‚gÏhçùH26})ì/:,7ýu)7S/—Ë–¥ÇÁ½ª›SÇss XNÞ£ÑȲ ÓƒbçÏ+‘H˜ü¤×ëYþ^*•2&»Óé(ÐéÈ?ép.ðù|Êd2º~ýº±†¼óÜDž•tY„á…3r¹ló•µ…Jka$^¯W…BÁt‰>ÒŽ`ÁÌuQ:¦tîf„F"ÂËq÷ß§?ýéOÿŸ¾ˆåxkŽÁ` Ï~ö³Vv‚ùêt:V>0°¸âºd¢tLœ€‹´}·9<Ùaœ’9»s,6Ó{ÞÓÒw¾×ù/oW¥rT"­Õ|úë¿.(“éË㑾üå¸z½©mä0yhjØh ’Ê~”‹)õ¢û‘då0—tfa•ÇÆ‰šÉd \Jú¾ˆØ3ØGBÑq±Q¦Åmˆ³—VW¸2 Ï(n¦å-ÀîpxÔÈvˆËæ3#g¯¡eó©Õj º%´0­Ü;÷{SZLÀ€¡…#M# òÖÖ–9PÝȤjµj±7”‰î¡”沦ÌuÀ)zØ;3¥ãÞ žÑp8ÔÚÚÚh¤lK™LÄN«ÕR¹\¶Ø'´–Vjì÷•ÙÚÒµlVélÖ@ 0ì¹áh¤Øþ¾4©½±aŒŸÏç3CŒ«k”òz½æ”FÇêêq¯÷z=½ôÒKºuë–¶··â MÜ ÀüÇÍ; (ó’U8 tòÊÝ\YQ#·ƬA¦{5&´VS¡VÓõÓ§5öõè~ã7ÔjµŒiEHWÖg=ôÞóž÷h{{ÛX|ÊÍ’$”¹‘&pOa¿Y_¼ókÌcxÂ…íº ™Ÿ¬C®ö$àÐmkØëõôòË/ëSŸúÔBg’å¸{Æ’\Ž7=(·¡•¡ÔÌ"…F‹Sôh4R&“1C‡ßï7f @bsŸN§Êd2 )û·²øi¼†ú¹Ÿ{›üþ vvv¬”GÅ'?™ÕêjAívW~¿ìûÃXŽèÈÁg僑ñz½æ~&{…·/­ºØÜaº(û%“É…ÞÁ8”³Ù¬E‚ûææR‚ŸOçÎÓx<Ö믿n@™çAYPÇA®V«ÙÑï÷µ½½mß—ç-w±(‹1õío[«««V¢Gë‰9Ê••d ù&Î;³À*#¿ØØØ°ûÙn·â‰º]õƒAõ}>Mçú¼F£¡B¡`ºdtu®Þ“C$ÑùóçõðÃëêÕ«VV…5—dkz×r¹,¿ÿ¨¯°+O€ýì#Má}¬V«*‹ß§áœL&Z[[Óþþ¾"‘ˆ2™Œööölþ²F³þrðt™éå¸;Çr,Ç›œäÝn0SlpniT’•ÁKs’u3gÄlPrË.n;2²Àf3± \‡Û_´R©ËÄ€íB$ŽýŽòJ&€‘0.¨r™!Ø+L,|Žd2i ØÍC{(ÉÊ‘”`¸-)eRޤt(x¸Ú#J†.ƒ‚îŽk#’„ïánhÕjÕž§tœWÈóƒ9ÃÅŒÞÐe«Õª¹r¹V×ÝÍ}&/P:ÎäYsh Äv‡ÜÉb±hÚ{ݼyS‰DB¹\Îî!º57oÆ&•J)“ÉèààÀ6aþÇ4åê'Ncs' \YYQ¹\6Á?ú4J“…BAµZM©Tj¡› ÌZµZµ¬EÀ±k¼Â„‚¦1‰hg2Ñy¯WÁjUµy‰“÷f8‘H¨^¯ Ÿ¬¯+{õªŠ•ŠZó{Éá…w7“É(.t¾áàC0;mÑ0ô¸úQ÷™¢™c>ŸOÙlVçÎÓþþ¾|>ŸiE‘4`fáç0ŸOߺ¥ÖÊŠö=çÀ)¨V«Y&AõétZ­VKgšMµæ ,ú)³þPeàÝá3óN<û쳺víš®\¹bŽ_Êáè“iÕ‡üí2‡"æs­VS:60œN§ÍðS.—­tží-šdžU>Ÿ×ÖÖ–±·n4U€%\Žå XŽ7=ؘn ¶ f‚ ‹ç%‘¸…ÝpYÀM:V£Ñ0Wít:µ = ‹«t¼I£§"–ÉuQ¶FjµZÔŒ~ŒèXWÐ/;[a¹d,Ô€c‚€:”‘%YH1l æ6HJŠårÙ>›ÇãQµZ5A?@ 6Ì 3•J©Óé(—Ëi4i{{Û4S€Bœ³üL´Z”§ˆ0qËL’¢@¾»Ñ”|3l®Ü+7ß‘9U©T¬$ p¢¼Êƒÿ§LʼŒÅbÆÚí¶åHþ Ƨ-`Ò:%]@4`à¶²²¢ÃÃCÓY1w¹Þ^¯§r¹ìD&Ü^¬”÷÷÷¦s ‡*„ü®¹6’ø@~³ÙT"V/S¸^7°ê¶Ü zíµ×Ç%™Žü€:kkÊݼ©Þùóêt:v_aþ`§‰•ÁÕJ9­"ÏÖ50Qzå°Àü&&% éÚµkªÕjöó¾ÃÄI²~¾°Û‰éT©jU·/^ÔtþLy×1Àäóy»—Á`P~ŸO©Á@ÛÙìBdÛÍÄ»Ï:溗ÑTºÑ?‰DÂØgI&àpÇÚçêFŒ]GêÑív-C¹ˆëPŽÅb¦ †õŒÇãÖi†ìÎN§£S§Niww×´ÇKÈr,àr¼é[Ç¢KL@ç+à3ýIYHY@q7 Åb1+ _¿~]étúû\†, žjµj %7ØL+®®Ó¶$c²pפãÅ¥CNó#È«T*VF„¡¢¼C)¶ÃSƒ.ÛétŒM<»@JW€HtkhÎúý¾J¥’úý¾ ã¹W˜'Üç‹0¶“ï a#Ýhø$™k™Pjîy¿ß·g ƒ û…¶ Í™Ë ÁJÑ~Œäñx¬z½nσèf³iŒ!à°ãx—ƒkÙ‚ÌÿX,¦7ÞxC~¿ß˜DÞ‚ã×ÖÖì=_Ž»{,ƒ —ãM@ô8ˆ¸fnH1 … ._Ê]”ª$Ù†˜ÏçíTÝn· ÈÀ>QfJ¥R¦›A—(w>@{`Åm +Äæ{"ÉÌ|?—E#ÌŸ™ŸÍ÷¥|‡#Ѱ,øFôS\3¦ ®M’10hàèB++JXh¹`g‡Ü36J Ü#²ì|~> ÷ m ?y€¦ÓéQôȸåNœŸn¹@áG:°p`p#cˆ®…k46WF†ÅºSÇŸ#aŽØÄr¹l¡× ЗQJ¯×ë ý+wÞ—5pXrKø´x㞣?hºJ¥’9¹y¾©TJ͵5…•œœ^¯gAºÂ¸ò†jµªÁƆú++Ú¸~]­ùýá@«k!Ê‹Mù‘wL:ê:PaÎÃàÂ.ollØAW—½'s{ø\YY9Š5µ¾¿¯òꪆóC÷³sŸ6{ÑhTé[·4 ÔœK<`ö!xœyèÎo†«½t LH\¸¬%”g‰ ‚éEãÈà`³MÆ# *eÿƒƒ+{½^kQˆsZ’ÉLúý¾^9¸.ÇÝ=–p9Þô ¯Œ²ˆtl>pœÒÑBH9p6›Y)& ö…_œ’ ÛÛÛ’d› ®LÊİ>€RX)œŽü’då@ æ€'¥bzn"^Ç KNZ£ÑP Ð… l³¢DÙÎu‡Ãa­­­@‚!;sæŒ1„Ü\±è¸Nô‘µZÍî7 ' ZÉppÄ™ˆ+W#š/J‹'6_¢°0~Ø(€(%:À¬›Ï1‘H¨Óé¨\.›™ƒ28 ¼B¡`%2ݰ; Ê‹nç‡l6kÌ\,S·ÛU>Ÿ7F Ja`v:=êB| G™ “L&-†„’:íã¼^¯õ+æ}À¸Ã{Àµ3_ݼ»V«eº8@4^£ÑHÓÍMõ£QenÜ0‹. 0í‚Ç£Þá¡¶î¿_™FC÷ÏY-÷ÐÀ|B»F' Ø=$!¢Uè-LtÏokkKÝnWµZÍdÌÿz½®F£aN\$"ÊÆ£‘îã ͼ^5|д²±XÌúsˆÁlµZêÔëZ¯T´—Ï+0gÛù,nœÖnY݃ƒÁÀ\ûtšAs‡yƒ9„¡ªV«i8ªP(È—ŽØ?וïF>‘H Åb±hIЋD ÷ ‘H,Ì;Z÷‘ý¸w÷XÀåxÓÃu­‡Q«ÕŒá†…°Â)Z:ŽK¡”3ˆ^Š2 å!²ÅÖÖÖ”Íf­„Lé G—Ê9FÃX!ÊȈçÝÒf4v,Ø”ãó¸ ²ÃÃC½üò˺uë–õwH~‰Š ŒCX,  M!Z¤@ `qµZM‘Hä(ÃlþùgÒ±® ÀDY™?,ÃdÁ>âf#ÉØëõ´µµeÌ#%tÊÁnù‹Èô[\ƒ×ë5ãš$‹¾¡DEë3XÊl6k‡J¬”ïÑfRR#ÎemmMù|Þþ-¥@ØÀ; FŒÏ„É&*‘HØ<•Žúüòy766Ôëõ  wEC6´µµ¥jµjåvÊýH˜çxw°}ÕjUétÚd­VËJëä#ÂB40ó †Cí­¯+[.ë°R±ç+Érô(âÖ=<<ÔµÙLµ'´vù²zûû&‘ qÏaŸ<¯ýý}˜˜ˆG‡&?À›Íf­·-åUW+çFëб×ë)µ³£L¥¢—77UžJ¥Ò‚‹ž{Óh4”Ïç%IgùÇcU67U©TŒ9ã `¥T;u Éd2ö½%Y 9ì2]>;kÆ®û¹çž³g [Èú Iùf1êþûï×ûßÿ~IÇZk·³ _Sêæ=ˆ»Q–ãîK¸oz°ÐR2„es™3ô/D}ÀD¹­ŽØ8)q™ÀiÆŠƒÅo:êöíÛ&‚‡! $GTeXÀ Cš%XA6#zˆž\6“Ï€±‡N‡¢V«™ M®[€'LÐöö¶•ª+ü?¥áx Œ˜7*K”[2w5TüLô¢dÐ.ÒNK:Ö|ÁFò¼ÝŸÚã±¶.^TªZÕæö¶• 9¼À4r`@’1 ´¹¹©f³i,r,3§2ïÚ7I¦%$Þ &Îår* v(<<ëK 8…½çÏ\½^¿ßW.—³6vnP6¥ôƒƒƒ…Ò=ìÞÁÁ­+NG—.]Ò+¯¼¢Î»F€*϶‘4‚¥p9–p9Þô Ä,Q¤ìÂ…hŸ’Ì‹6¡©œ²a&`½^Ï€d³Ù´òå`ð¨§-¡Ë68˜NÞ°ôØl°HZЂI²|¸B¡` ú?@ :)š¼Óáƒ2#æ6nØ-6QI¶éâ˜DïsâÄ +rÿ]¦Ï+É4~°e”-«Õª‰æ¹.>;­¶ù%·Ä„ë§3Ïšòëêêªt{°rãñØÜ¿0„1ÀÌ8pÀ"O&kMÖl6 ä¹Yg”§aNܲ"1F”_ùÚ­¹¬§¤…¨6ÿÁ``,xö0º€A>/ò€“$+'‡B! ΆÅ+ Ø766Œ™åžK2},,5WëV>¯`¿¯d©dž óÚ-Ïóyù¼¶ÏœÑúk¯éL½n¦K`£¸ÿ„`X‘zaÑÝrªtœWI[I×tEfaÈï×¹K—ïtôòh2? ¸Aá°¸+jT*®VÕ‡U—X÷ööŒ‰uCÀaqõÒdwwWÍfÓ>+s‚uM’]O2™´ª߃c¡P°¹ ‹Çš„VÐ|vW’éa“Ýn ¬Ÿ¨x¦ÓâÖÝÜÜ”$Ë”Cë7T(ì3®®®.h[3™ŒÖÖÖÌ9 ëÈÜ„ŠÌó@M§SûŸO¹\Θj¿ßoYˆcsÝo®3 f×Àðxtê_þEÉZMW.\Ðpމ—*‹f2BË| ‡ÃÚT¬TT:qB‡s)‰kÜáÝAF‰D”Ífuùòe½ú꫺qã†^|ñE{§`ó¶··í½çþÇb1•J%+Õó,¥£lKWË»ðwe(H;˜¼‡€{XS·õ\·ÛU£ÑÐx‡k áÚ`ð(1Rбa“‡3ptgË(´{è¢Üx¾®ÓéXæÿC :L©›#&É6yØ€N_îìa8ÖÎÎŽ1¡8ŒiG©9—ËÙ×£­ÛÛÛ3F'™LêäÉ“òzÚ—íííÙ½…mA£øÄ]Ç-gN: ô¥tÇiµZÆÖ¹y“¥RÉ:ÂàÒäçQFv¯›È W× CH9 ‡3¥o·ß2Q(^¯Wù|Þ Ù—8Á§Ó©iLy'Æã±e;bšÁ”!$‰èæÍ›ŠD"* j4"auȺs%’´óÐC:ÿïè¡VKÛ¹œ=»p8¬ýý}»NÊÌÒ`\!>@À+À1 ø…Ñ¡o.Ì€ý$,Ïf…ŸÍÏ$Îe6›Y¸±Ûî 0¹»»«íím]½zÕÄö˜‚è‡ +E׃d2¹Z‹¾¹Ðg¸ea·3Ïͽ`ÎäáÁ¦¢Eå{¸à†9:™LŒ¹‰Åbö{ž/‡ ÜÒ0Yèô8ÔЕðˆá ðHiЫñxÜz3KÇF$!¸<ù9‡‡‡J¬¯kØïkõúuu×Ö4°"étÚÀ"]c0e…#5ÓiM}>­¾þºrõºJ€Vòy BG/É;ƒ‰Ö‘9Åû[; ¼s?y&’Ôít¿uKç_xAÉD/_¼¨mŸOÅbÑ~q':“·ÈÁÆï÷ëÔÞžÒ»»ú§S§4™Ï;æ,s}2l ºb¹ bÇÄÓÉ»GùÞçó™Î’÷äΊåiÞ_IvPã9N-‡ÒeY+•Š…åc¦ƒçßS•à0Lyx:êÒ¥KúÔ§>µ ¹\Ž»gxfnû€åXŽÇÀ¡øàƒ.ˆñÝMŒRm.—³ËGÙ¦x¯¬ IDAT pè–’Ý®”ƒ’sj¼x‹Û*òl*•²Þ´”.Yœa-ÄäÀ8Ñ‘ÁíâÁ=ŽD"ª×ë’´ðo¸§°¤ü9%Z4„(÷¾»-³([Öj5Ûp$ØaÓ£|NGÌ.ë Ë øå0h&»Ž<#:e2(»­Ê0WH2³l2±/ÄŸy‚PèÜjµÌ*\ƒëô†]rç2™€ÍfÓXL˜Eë€ZÊáfÀøÄ†9È ¦˜h#×Ä3 ä÷zuÏÿøòz<ºñÄšÌ;«4›M{OȘ«V«fr5 ƒ*L&*þÓ?)Ôíjçôi•ΞUpî´ÔM§SÝsÏ=Ö.Ž<>2ë¦Ó©²Ù¬½Ë8й 2Á 6.]RºRÑA.§7î½Wù“‰NZt«°Îh>ý~¿Vº]ýÈ‹/êÖÚšnž:e œkAOÇÜã}§´Îü§,<›Í¬5%eU7ÞŠuν“ÉDÇŠÌO>+]€|8ÖÁÁÁ‚Îx2=ùÙ|/>ÓÊÊŠ”K¥’ÝSÌr¼§_þò—ÚΫ3Ëqw¥p9þ· L\\M‚i6DNÄ”$(k š,ñµl¦l0”«øØ 2%ÙbÇBÈ@7H, %:IVÖ‚Q¡ôÃF(q»œÀ¶Xa…ØaÏ0ÊP6sMèÑbv7é¸ô¢ßï›ß-ó\göÊÊŠÒé´J6_6OtV´[ãg¹›!,¬f4µR¬$+aæóyÓcºåiJà“ÉDkkkJ&“Z]]]Ðf²8¹Nž Bz6TÄò0*årYápX¹\ΜÏ8®afÌÌl6«V«elU<·8IV–äçÿâæÚ1ÿaß&“‰šÍ¦I˜s`˜;˜f‚Á iºpÚʸ&æ'ï]sööö ÀxÕëõ½ëx±ÅI–…à%ÉÊ ”49ÅrzE—Å"Ðdå pLni %W· ‹Q»¹»å5°@ÑhTŠD"† X£¬ÈgÅõè¶CˆN‰@Cy›² ý‰Ý /د×k­ÓÜ0^®ûÌïq4Rr ƒ*‹zâ‰'´³³cl ¼Z­.ä´Á°†B!†°'€ct{n 7¸uËž”á%Ù½ásÊîfpåÞ¤Ói …C‰ë´…cÃæb´ÄcT ,`õÐ-ÒÑa<«T*-t¿™L&:yò¤1¹ñxÜ‚…WVVLë“Ê&ŒF´Ýn[´ l-ïO(ÒþþþB/bžI§Ó1ÇãQ>Ÿ·ˆŒPèÑ(UÆãqMÂa û}­Ý¸¡R2©Øêª=¯B¡ z½nz6O”Û···æ¤V&£f>¯@«¥õím­Þ¾-·«I,¦êá¡¢sÉ€Ç5&ú]ðù”­×µ~ù²Î߸¡H·«½bQ—NŸ–VW%¾æ‰ ×ËŒ~îÔÎŽ;;Jþâ/ª>/é’À¡²*ÁóÙlÖ¤¸¸ø¬K0ÅÌgdd[öû}e³Y3m¹€:ÌÙ©æ&9ä õ ‡Ã¦ûä½àÀJ¥Ìˆåñxì^#oH§ÓLã|íÚµe ø.KÈr¼éAi)leX#4B°@$ßfêæµI²ÖÖ= ºB˜¯×k¦ØÌ&€4Jwl®lºhj\ó…kæàçN&@®›vuuÕʨ°®–‘Ü0~&ù†ñxÜJÉĸÚ"˜6´@\'ƒr8& Ø=tFÏ>û¬eÑ¥\.[+µX,¶°¹¸:×i ³@ƒmb¤tÓ (§¼éÆëõj}}ÝÀ9Aµh%ÓIimãp8ÔÍ›7­ L$fÎ`2'¸¯°*” aîZ­–‰„z½ž øa¨WVVT.— ð¼×××ù¡” 3 À$æ£^¯[Ã=@°ïê ôÈ xO‘ƒÁ@ëëëÚÙÙQ¿ßW:6WéÊÊŠ€ö÷÷í üFîÐ9{V©RIg/]Ò+=¦ÉüÝ)—ËÊd2v¿akÇ㣮>kkkj6›ÆrO#ÝJ&µÛ﫸»«ìíÛÊݾ­sÁ †ÛÛª‡Ãòªƒ '’Ç£@0¨½k×”…”ª×µÒj)Þí*ÖéÈ7ª“HhëmoSmuU‡£‘Šó¤ÀØd21ã ˜ýýý}>ÉdR±ý}­^»¦îÃëÊÖ–jµš}=‡éÈHD9í-Æ2¤€0À«$+×ÒfŽ÷w»ÙlšÓˆk2â÷èaùÐ챞F£Q;€ñ~²¿å^'ïÏ‘÷—¿¯×ëÖe9îÞ±€Ëñ¦ .@‡š›©çÓ.h³DDG§Ó±|2I¶9"¶¦, ˜$OŒ• €‰òˆ Ùç¥Iʈ” ØüÙt)òý݈ˆF£¡d2¹à²%Ú†k‡ÃÖ›7N[É€Fv^&“1ûບa aËZ­–¹HaO¸”‹Ù q‡Ãa3 ;×étLΦ{È÷¢ kÃ=8¢¦Óéø#ºƒÍ p%Ô¢ƒ,¹´Ì#´”étZûûûÆØ"`wÅñ°.ÓLi·R©ØýÂýÍaY%~@×€5Dö®Ñˆò6 ˜Åt:µÏÜm3œN§U¯×Õíví3À°V«UcÅùÞ„w»]E£Q•Ëe»Žétj9’ü›õõu“P^æ 3õûuímoÓÿüϺï…tõï4ç> ÁW½^Ï€9À&•JissS¥RI­áP777µwö¬¢Š5›Š4›*T«:áhRÐè„Bê§RÚ__W3ÖpÞÁÅ5Vð3óù¼1Z˜ bÀvöõºî½rEÕtZ¯g2”ËÆæ¹FP®)™óƒŒ{^Ð9%‘H˜ƒ¯AÃߣýC§Œtƒw­Ùl*›Í.¬/˜Ðz½^Íf33qh lž÷iD³Ù4àév)ZŽ»w,àr¼éA¹fN:v%ƒAk3ÆBKÙ‘˜˜8¢?Qnù—œ:X 6ýN§cL ,`…?™`ãñØÌ ®þÐëèt:VZa£dò0#°Ð‡CkDØÄùý~åóyÛ|¸°“®#&ÔíìÐê÷ûö¹‰ œ wã놱Z®þ æ MQ½^·Í–2¨t¬£TG «@é‹¿ÃÙ Èuã+ØðÐåQn …BÆÒP.Äò™\À‡Ž €ƒàâú3™Œ@ÀÁÁ•JÝðqJd°_.s »ÇÆÌgôRêôz½ƒóG{³½½=ëNÁ|à÷0‰<{Ø.‘óù¼oWû†¡‚y[¬¬H÷,˜NëÚcé¾þgþy½üÈ#Z™X\mÙx<6W-Ìk*•R·ÛÕîÿI:««nnªÑh(‹iÚj)Üéh6j|x¨™Ç£H<.ïʊꀺsC‹1Þsã9~¸‰H”JÆ!Êž³ÙL«Ó©|õUµ’I=Ï= Ι\œÙ08øH2×· Ä»Q(´¿¿o<0€¸ ›˜À‡ˆ••}ä#щ'ôÅ/~Q7nܰµ‘x#bq¨¢0x”ïƒÁ ö÷÷m ãÀ1M³êš¸‹]æ1‡å¸»ÇÒ²ozx½GáÆ0î¯z½n9XD?¸ºL€.œ¸”)»± 2øÊz-˜3ô~ƒÁ@FÃ6rL¾Ž0g×Qìv AÌ.i¡‹Äl6S<7w.º0ôV”]6àÀg dÄÆ‹äÆxHGLšÛs—M—r,L(ÎC   ‹F’(´J®S›ãdrÔ‹–Ÿçv$„à²Ù¬Eî>< ¬3†»1q ²C’éÛˆ6á~7 ÛŒûý¾*•ŠÊå²=ºy Å„}åðà–Róù¼±CµZͺ–PÞåþHÇÀ‡Ø¡Á` t:­|>o%e×eŒ!9›L&uâÄ “‚K¥’¤ã¬LW_wúôi=üðà ½0¶’¬Gm©T2PÈCìÏóågH‹mÛí¶ªÕª3&é´®=ú¨Â½ž.^º¤Ã¹©ÄÌIº_.aåÜÏ„Óy_ÙlV£ñXãHDåXL¥TJƒsçÔÝÜT«XÔ¶Ç£Á|¾ñ°F`„rÛ΃Ac³™S舩.¬¬¬(ÝnëÁ—^R/Ó¿œ:¥p4jŒðê\ïX¯×í(IÍfS“ÉDétZ’,AÀÍåÐâõzU­VuöìÙï{7aÖÑöIG‡×½üò˶pX…ÁŒD" F2þ-Ï®^¯ëG~äG´¾¾n‡bd ]ƒkãÊÊŠåý¹ïÃÒ²ÒÒ²ob`I$ÖÕËíÁÉc†tìJuËRäk¡£$æÆÉå"ÉÀ¬%VÜ{€FJ˜BJ6„Ï¢±áÄüƒbIp,²K ˆ’•ùÀçtî酠[|$ cq\&Æï÷ÛÿSBd"\g3“dÀÆPÅ×s¿Æãã†óäÙM§S3ƒÀ⹟öq6›)ŸÏá¾åÁ††1ªÕjÙfË&ŽÓÆèàÂá°Ý ƒR©”™|` ¶Ì%Êð”Ƀ’ɤ*•Ši©Üðl\°åétª‹/êÉ'ŸT.—³ƒŽUL$@&“‰1~ÜCž›>?°ÐëõÚþ…B!c0G£‘1”Ü#8~ɧsYÌÀ<ì«7ÒëõÔžÍÔ*TÜÞV¾\V=Ÿ—w~ìF†œD+†v¡=º+€ ú=ؘ¡ùE Š ™²+G`=ƒý|6_6 I2a8)ù¸€íÎÍ–ÍvŽÒ, ³P(¨V«YyPæ2¤­VË Â\er@@™M0̽@ñÙ‡Ã¡Í ¢[jàv ×% ƒ Óì–É`)µÂlBÉ@ÄFé~¿n·k±A|J¥b_«@£”Oiã)σùëñxLsÃê†ûÂl¹l!ßmÞÌ:8·9pa’a£iä3º%f·uáÀëUkcC‘ZM…«W 4=yRáyÀ7Iæ<%‹“ú^2ê˜ÿ€L]@@™LÆÐ9ôpbþ É̃dú|>­z½ºøòËÊèöƆ¶|P‡ó¶ÒQù€éêãÐ&39D¢ÏHhYÏXƒ&“‰nß¾mîa$#¬è&až¹7¬#Èf³™=#®w Æ»Ï¡†w¶Ýn[9™÷À=Lö)e»¬ûáá¡^}õÕ%¼‹ÇÒ²oz°˜°)ºZô~’l‘•d%Pâ-0nÐ ŒE‹ ˜;P,­Å º¬;YÊS,¢äû¹Æ€ßá>a¾°Pl\°H¸žÉpcS'Š„ÏÌçÁqHiÔm5är›Í¦Ýc@'Ú/ ±XL§OŸV4Õîî®õvÜ Kì¦R)Ó8b” ´Øï÷•ÉdôðÃëàà@o¼ñ†Æã±éôØœ]¶pc‹–ŠMëÎþ¬’Ì ™;8xù367X‘t:­J¥bó€?'$¶ ó‡Ù„ü¼H$¢­­-e³YIÇmäØè1¸°aS^½³©yÄòÓ'I™LÆ@/sŠMfææ9Ãd2Q£Ñ°C¥?×¥ ƒÊœôR¤ƒA‹~ñz½:èõ4xì1e··µùÚkJ|ó›ºõàƒöÞÂ:‹EU«U­­­éààÀæì0`ÖÕr"ÿ@;ê:WaéëõºÍæ¦k˜Éd2欞ǺgwW«¯¿®þÊŠþùÁU‡åŸ3ܮ˄q*‹  ÊårÆPÇãq•Ëe3ºÀèq™ï˜9xG‰ZbnºF/žg ÐÁÁ’ɤ% p­€?ÇcÕ®¤„9ÈlF£Q;ÁðÇãqíìì(—˙榞9˜_Ž»w,M Ëñ¦€Ä²Á´[fâ×xŸW2™4Í!#¨ü’ŽA8à³×ëéÌ™3ßw}Ì)X£n·kÆ÷™‚é@F ¸» éD"aZBI¦‰u;£pp0Ç< Îu³ÂVµZ-cûpͦÓi ç=¡ìÍóšL§z#™ÔåÇ× ‘н/¾¨·ïî*8?‹EÕëuE£QÓŠrÑŸår9e³YƒG­"¬’ŒUæÞæóy­¯¯K’Ö××âw¸§¤ dÆc]ü—ÑÚë¯kûäI½ðö·«?ŸW¬A¼+˜ËS0Ä\æ'€QµZ]±Tøœ°v‘HÄÌNtÄá=ã™ò9`TáÐÉߣ;u î¡”¹K®# M/·jµ*ŸÏ§z½n2$Ì}ØCw\Ž»s,{/Ç=ÐÆÜwß}¦_cóaQCÏË´²²bÀ…2.>œ€ù|~Áhàv†H&“–f/gòõ’Œ5q;zHÇ^J9.ÃDY‡n0b€O ùù|Û¥D:n/bÃas8úKég:šÎËÕ¸¹ X 0mtÜŽÒ€ÀÕXQFƒ)ãÞÓ­„Žr`¾^¯›¹±±¡F£¡% »~—飫å%W{ç–·¸™ëX¥„ ó¸rËœív[‡‡‡Æ1Çr¹œmºDú¸YmD™¸Ï„9D&!å¶F£aeÔØ¼›q„C¡Cß\¯×kóÅÕLÖëuÕj5år9;Ô¤R)c{Üö\®€{"»ìѤ ‡CHD“Pn¨\˜O±XL=ö˜¾ýíoÛû 8pÂæòz½^M'åvvtæÆ M½^•OœPicCÝùgvM,étÚ´…ÌgæÑ)æ×Ë<æýrßëv»­µµ5G#…ªU­íîªP©¨ëê½÷ê`~PàÚz.𦫠óuÆ5×°vq{{{vÀ œ=‹Yï\Þ%Çc%Þf³©L&cec×)‡P¦'†C 2 Ö3:ÑÊ‘ƒµtÓävr50¿0š0ÇG_üâ—½€ïâ±ä€—ãM6:´n,ú.Àsf’lsfÑfÑ£\ÊFá÷ûõÞ÷¾W<ð€þôOÿTûûûö³Y¤ÝVc÷FúéFClo+>›©ç÷ë»Á ¾zꔾ;/=¹l!Z&J$>ŸO‰DBFC‡‡‡VndѼprwsþ0¸%»étjllK£Ñ0 C°1À5›n‘ë¥¤ÊæCIˆ.ƒÁÀº|à*¥„×ëõT¯×U,-§ 6sÆf´µµe9‹ÅbÑ6ŒÑh¤T*eŒ#eøv»mˆXÁPÞ³P(h0ؽ½pႉ„^zé%ûºÙl¦d2)éØMÉdL7Ê}q3ÛÈ=d¾qxàçûý~Û<3”ÊápXårY‘HDJ$ ]B"‘ˆÅŒðìÇ•ÉdŒrc}ÁZ\f eóF£a÷™2æp8Ôöö¶$Y¹Û=p]€Êp8¬k׮ȣ¤M¹X:—¤él¦Î¹sz!Ö=»»*Þ¾­õ7ÞP³XÔV±¨éÉ“Íy„XK2ý€7*ï*¹š”«™ ˜µxçûý¾fáâׯëÄÁ¢í¶z¡®®­©vö¬|Á r^¯9Ëp¸]9ˆÁxÃVóLé~C :±Q<\è®\Cë‡ÞÊÏ{óÜÑòU*cŸÛí¶ÉE8$Ôëus¹O§S­­­Y`$ îá‹õ–ÊkœÇã±÷ã îá帻Ç.Ç›”D1 rÜl:4H”^ÜòY{,N•JÅД±N:¥GyDüàõ /Xg ô@œwJúµ›7õH·«±œ >è¾nWÿW½®—VVôÛ««º×„áöD¦¼ŠÃÍ™ëbCwõ˜Øxˆžºñ0ÁàQOà`0¨ƒƒ+5*•JiggÇJ§ü[Ja®³”ïÅs£üÇ&D™¹ÑhØæÉ-É ÝnW§NÒ;ßùNF#½ð ֎ Æ. ÙÏ`“¦œ†Ë4›ÍëÇuñl¤£_\̸Ÿ™›ÕjÕJû³ÙL;;;Æ8RžóùÑP¹¢I ì‡ÀQ$Y¸o.CåFÆð½a¤8¹9oè790\À‚Y‚ÃT­V“$‹ŽÁy.ɲ™?0ìû%ºêõ“'u²ÙTîÖ-=tp Ã×_×í\NÃÕUiÀ9¸Àhª2™Œ]7fV@ eñv«¥@³©sÕªVK%ùÆcUÓi½zþ¼Z¹œªµšÎÎçº`ž9Æ "ž`’‡0ž´£$ šç‚TH@  f³©\.·`£ ÌáÏÍá#™LêÖ­[È`Ba$Óé´é—C¡ý9÷ fÙmƒ«MÅ‚ÏÅÏ–dÀšÃ¬£$íìì¨Õj©P(X~ãrܽcY^ŽzP>wîœ4a¥`ü~¿1]€ÊšôU•d›«$;µ³PKG I>Ÿ×ÆÆ†¾ûÝïZè0À,‹éG›M}~kK>I¾ãº'’&þï'tåôik¯Å&¬'iI Ô€S7¶n ”|`\ hÄ¡K&“æöD—çº5···­w'L%`•˜6×Òh4Œ½@»´··gz»{ï½WNG7nܰ2/ß·Õj-h)ñ¹ñnF!åpîɹsç̉KŽò*N]X´ÝÝ]Ó«a‚H&“¶YÂ"­®®.<36<Äø˜\`% fŽQ¦“dq.s k˜Å½ K¥?.šI4‹n©‘N-dýTÐuI2€¶¶¶fáåMÆc=ÍÆcy‡CÅz=ùç‡ÂA$¢ÖÊŠn¬®Ê³¶¦Ý@@9‹ƒI&nô ÀpsîÜ9cöxý~¿R©”¶¶¶¬$ Gª"IÅbQ£ÑÈ¢z`ápÛ–Ëe%“I»$Ôj5­¬¬(™LÊç;j‡³wLIÌCºžð5hG£‘=72 ÆýNíóòJÔHèG³Ün·¿Ïµ¾wßX2€oÁñ™Ï|Fñ¡W_}U‘HDï~÷»õÛ¿ýÛºï¾ûìkƒ>ùÉOêOþäOtxx¨'Ÿ|R¿ÿû¿¯'NØ×ܾ}[ÿøÇõÍo~S‘HDþð‡õ¹Ï}ÎÊ©ÿ³øÀØé¦g 5e%t2äÈÁˆ0øw”‹Ñ"ÁnÀº¬S4Õÿ{õªé÷ÿMæïÎ1‘ô½hT›oÑhÔÀžëÞc3õûýÆ4°è²‰¢}ä¤í¶Zóz½ªÕjÆàÀİ8KG›;÷Ýuõ¹@˜ ñz½ªT*ÚØØ0ð"É6%6/X97ú76ûõõu½ç=ïQ³ÙÔ—¿üe3ÏÀ< :¬Rj$ž„kƒmİ)g³Y=ðÀºvíšnݺ¥l6kÏÎ5¯¸FžF£¡p8¬b±h˜25¬,€`ÅÁÍå;ØV6Wʸh¬ˆ´AÓ—L&mƒv]¨’ ä¹9}n,M$1ŽXIvM¼ÑhT7nÜ0PîëÎî/n‰ ·»»«|>¯J¥¢sçΨ,0Ÿî»ï>½ãïÐt:ÕW¾ò+góþ%Yà8×ÊsæžÁJ"|H‹z¿étªÙt*o«¥u¯W‘FCÑñX³áP~Gž9€{<šù|šú|:ŒÅÔ\YQ#R{2±¶‚®|0„g8šÅÍ …±“dÌ7Ï"‘M¼ëètðÞÉhd¹®#¼Ýn[)Ú5r¾òŽ8í5XcÜûÎs€AåžÌf3e³YkÍç~}£ÑP>Ÿ7ÐÇÁÖ}Î\Ï3Ï<³dïâ±dß‚ã[ßú–>þñëïx‡Æã±~ó7SO=õ”®\¹beÊ_ÿõ_×W¾ò}éK_R6›Õ'>ñ }àÐóÏ?oe‰÷¿ÿýÊçóúÎw¾£jµª~ô£šÍfú¾ðïº@‹Þ,žtìfeÃvA± I §p„î©TJ’t¾ß×Ì7£ÏðIz[·«³‡‡º<_àaµ`p5JÇŽãñxlî.ðhŠ0€ŒF#ÓÂ\<øœ,ðl2né—1ì…{ß?néÐ …™˜Íf:þ¼±E•JÅW(Òã?®Ç{L£ÑH¥RI¯¼òÊÂ3ƒ©Âm{xxheCI&¨—dì/¬'¥êË—/›Ûx_ÑhtAÍfÌ€e¦ÓiÓv±Ù3/Ø|éB„ Ñ5SÚ‡ÚÜÜ4@Ï&ʯN§£µµ5 wcŠØ€ùŒ°Ð€WÔO ׈3ç'ÏyeeE7oÞT.—S­V3† Iæâd2Q.—3º··gŸi:ªR©(ŸÏ+‘H¨X,êÞ{ï5Çv¥R1¦iï'ñJä(’ó×ï÷íÚ™S’Œ$…wY’¦’f©”ªá°ãqkßpÄ™ øâ׸ÓQvÌÍ÷FÚÝݵ6y°ÒHÅèCÑÆÁŽò5hp‘pàä}eÀžr}ÒÑA‰Ò1ëÏm+ï-­‰„šÍ¦±otÇá°ãõzµ¹¹©r¹lU@5UÚ²~Ð5F’1Ž À&‡»ƒƒåóy3±Á¤ÃèJZØ,ÇÝ9– à€Q.—U(ô­o}Kï}ï{­tøÇüÇúЇ>$IÚÝÝÕÉ“'õ7ó7zúé§õ·û·úÀ> ­­-ËÞúÒ—¾¤}ìc*•JÿK'BÀóçÏÛé€ä²\)6*\h”N]Ð@)ƒÞ½ü=`F­Oæoîîê?•Ë?Ôif,é/òyý?óÁ;K\·òJÜå<ØâGø|v³ÝÝ]­®®š@…ë’ÙÍ€I Ñ00¨nyàT«ÕL³ÀZ]]U£ÑP³Ù´’l6«û±Ó‡>ô!{^µZMôG¤«W¯ªÑhèààÀ\Ülxløõz]'Ož4àã:ÀaQÈÄ ™N§íóÀ,Â&¢!•dNPIìL©–Mûãš vvvìß 3„™„qÆt€ÃK45g¬$:uJ+++ÚÞÞ^èLƒ  €(Ðq¬À`âºa;Ž•µÇBšau(è Éa¤LK·ñx¬{î¹GçÏŸW«ÕÒåË—-FÚAâ~ƒA½ûÝïÖ£>ª¯}íkzñÅ•Éd´¿¿¯T*µ:pWól>0¯˜u‰„:Ž•/¹wÕjUÉdÒ 8 Þ!<t:­r¹¬p8lý¦€jµš666ì€H”:^€;÷†F–ÆP̃÷˜ç+ɘvW)±áôBÇM ÀÆ¡ŒK†ûâÅ‹ºté’­¡€` ¬‹gù,©TJápXgΜѫ¯¾ª•••Ëe›ÏÜ6ì7‘A0ñÌ…jµº0gaôqsÃ<†ùž­VKÙlÖLe8vS©”=§t:mf"åér¹lZ‰ÄÿÏÞ»I~žUž'+3«*«²ò~©®®nu·Ü’Û–,[WÔjK-lã€0X8›…p;˜16ÚÂÄŽ‰`×XÏ2ðeÌÄ,ll¤AF²eKØ`][­¾©»«²ò~ϬÊKí‡êßSO¶aÁ­¢òè°Ü]•ù¿¼ÿÿ{Þóœs+Cs-Ø£ fÀsC4Àÿ¦ìÝô¦coi'×øØÞÞÖG>ò8qB7Ýt“$©P(X¿ù|Þòó …‚òùüÄ¿“¢ÏÏ\=>þñ+ÛŸH’½pè (deGJL>FÄ3E°jèâ0TàR%iß·œ‚a\t ᵌ¥+Œ/Ìùùycó(Õ²o¾w&¥Y^æ‘HÄvà>üæÉ/‚äû$`:Žjµš•‰Ÿ·ÅCñ0¼ápQ>ú¿é?ý§ßÒ` 3†¤Ói냌 Ä÷!ö%QÊèˆî%¼I“ú?:zÀd1_èQœL&'Øk˜a6<ƒÁÀL<[°l0‡½^Ïr“ɤ±‰°iù|~¢ÔŒdÁÏár¹l×* úüùóúæ7¿is¨R©˜‘(Û1Çãq+«SއêÕj¶Ql·Û6ß`É¥]Ýh4R¯×S­VS­V³ÿF†Ç•H$ì¾ñÝ>ÞÄkù}îíím®ÌS¯•\YY±8 ²Ù¬r¹œ±eô!ýÃ?üƒ¾ò•¯ü³? ÃÄðÿýOýŒýèGõ‘|Äþ³ÙÔ¬ÓL% ^´0Ò®–’¢}ÊF° €@€}»/ØJ‡í™W·é\Ñ2y±4 ç„ó•—)&@åIvÕ0f”V»,Zè²٬iK»ýoÑÁ ËîâåM)Å F Y›››º|ù²†Ã¡666tñâEõû}=ðÀHž{î9=ñÄzæ™g,ve~~^ËËË÷Ø#"˜`0‰CÉår¦ûb^PŠ«V«Æ¤âêä|gÜ}¥äKna·ÛhqŤÕ:­Ã‡ŸÖ¹soÖþÏ¿£÷ïþ½âñëÛŠVVH’Egðý¾\ ‹ HČ⧗––´¾¾n¢~4\>¾ƒ&äÝn×Jä83S©”•#ƒÁ ¹KÑr…B!•J%%0](™ÂBâ0åw{½žöíÛg ç¹7©pÞ’”N§ àÓš'pý¬$Ût0(¹¢?å»ÈÓ“¤r¹¬D"¡­­--//›F›Ðe6ívÛo2-Ë岪ժVWWÕívµ±±aànffÆd\Œ9pÀ|8¶yLi¿\.›V}ï ®=ó˜®!lLè#ÎwòÜÀ,2O ÷Ñ<Ìmܽ°ÓÍfÓ6_È.Ðé¢Íô’R ÐRÅ˜Ž½=¦ àkx|øÃÖC=¤/}éKî^tf€ F±X4ÖoyyùÛ˜>ÚM]Í 2æææ‹Å&þH2–ƒ…Ñ>»nzšŽL¶À‰Ïn·Û¶flI2–Íëí¶··õìü¼®•JzþJ+0X˜2´L&3Ñ£§+çÀ¹¢±¢ìãï>ªÅW½^7VÓ»ž1pH²—ºwS³,..Z÷ ˜$îßÉ"EÞwúôi=ÿüój6›* zä‘GT(”Éd”Ëå‹Å´¾¾n:/¯¡ÃÅÚï÷­E%mX ˜ J¿hÉZÃ틹A’Ýçv»màŽkäzÀF‘øÞ÷þ¿zÝëþA’ô»¿ûÛêvw:–Äb1Ëv$>„’e=@'Œ´×éõû}]¸pÁÌ ‘HÄ6;ôñÅLâs÷`ÇÐòlŠ`y~õz}BËż¬×ëÊårÊçó’˜›Ä ÅÀ4À1\,­ÛàÈGüxvºR©˜ä9dÎz7>ƒÈ›n·«õõu;祥%s†‡B;½é†HDSdžìÈ([,2åyæ"Î_d¸Æ›Í¦×£Ïï!d ™LÆL3[[[–Û·ººj=y ”û|KºÆÀä9GʱƒÁÀ20a<=“‹©‹ßçº"›!®éúë¯W2™T.—³Íb8¶=cZžŽ)| Žíím}èCÒg>ó=úè£:|øðÄ¿ßvÛm ‡Ãzä‘GìïÖ××õì³Ïêøñã’¤»ï¾[Ï>û¬Ö××íg~øaÍÍÍé¶ÛnûŽÉç£ìÐÝàÂK§ÓöÒbÑeÁ¡„åûššhù=€a(ÒÅã¯Jø)&É׃u$ÄðB;1ŸÄ;š6þ æ·¥7:p®°Kìäóù¼-®Å¥Ý0jX+XŠz½>QŽdúüÂÉ¿÷û}9sFŸüä'õéOZ=ôž|òIËZôzÃ¥¥%U«U+7Äv:U«UÓ,RCŸàä>£µ"£ ÀÛn·­t A·†ö &ß ‹ÅtèÐ!-//+êüùóz×»þ‹ø†$éw~ç7T©4ÕétLœ‹Å¬|Ê=†¡eAe#æÛÅa˜ÁìÃÜ•d†˜Âñxlíï¸÷hDÙ¨a:ðÌ c¿‘HDÕjÕ®N`}j‰³Á€D°Kù MÔ ×ƒã\oD˜1Ïy£Ñ0Æ›¹ŽqhÿþývŒ­V˺PƒA©0Ì0e—.]Òp¸âÍf­ìO)ÙGãÔëucÁÛí¶2™Œç¡C‡Ôï÷­?0›LL¼›€~cXâRÒå¹ËårZ¸âXîv»J¥Röï¼Ñ1ãZ§O0L+ÏõÒÒ’]cÂÞ‰~aÓËyûBÉžw‡$Û¨<óÌ3Z__7ÆÏGã¤R);_o¼™Ž½9‚ûØÇ>ö?û ¦ã;?ýÓ?­O}êSúÓ?ýS­¬¬Ø œ] ŽÓO|âºå–[Ôh4ôS?õSZZZÒƒ>¨™™9rDŸþô§õðÃëæ›oÖóÏ?¯~ðƒúÑýQýàþà¿è8677õ«¿ú«¦9ò}i .ÔwE™0‘HØ Žòú>|^”°^dÙùˆ˜ñx¬úÜœîj4”¿£ÍHÒ³KKú/ù¼±’}hùJ<>ð¶% +q ”È<èxùŒ:Œ@ Œ€Àla`1ðÚIØX/@3l ì®^Zï¥ÓicÀ0ñäÝu Aw‹N§cº.t‚€y¯aò ¬+ÀqkkËJ]D¯¬®®š«ÀÂ&ckkKétZÁ`P•JEårYÁ`к„<ø5U««j4VôÍo¾K·Üòy%“qs–¢í„TRº†­æÞ#Wð¦€ç&É@Ü`00Cf´|dÉáì®×ëÆ¼ó,0ßø\‚Yð ÒŽÇãvÍ1rx¶Ö6 xæw¼AFÞ³œ8Á¹OžõÌd2ö3Þí»àÌÌÌ(™LZ f¯[o½U'OžÔ™3g&˜8t„¨K²çrl¢Ð Ó…(3ø‚•÷]>ˆÇáxc±˜9ï™ÓF6_táYæþ£Y俉„½+Ð}"aáýi Ç:÷$À=Û5ã¹ôæ–×¢ûe^ ÏD‚ õÒK/é£ý脦y:öΘ2€¯Áñ»¿û»j4:yò¤öíÛgþøÿØ~æ·~ë·ôÀè½ï}¯î¹ç-,,è/þâ/&Z}þóŸ×üü¼î¹ç½÷½ïÕ< ßøßøŽ‡²—/Q ñ®HigqËçóÐBùN IæFe‚¹¼üJ:­Q  ñ¿ð˜ÇÚ £ýí뮳El8jmmÍÀ'Ÿë³ë4ÝurÌ€ÊB€Zº: k±Æu ¶ƒÜ6À™7 ‡CcÅçJšè&BÉRl½^·ÿu°7 _·ÛU±XT¹\¶…€ëÁ€…@_8T.—uÝu×Yév8ªT*iaaAÙlÖbi(Ÿõz=sXrý8´XW³]¾Ô“‹ÅÇ {å•Wìž`r¡Löîwÿ®¿þ[’¤ßÿýO¨×š¨S ÊL&cm¾ä˜bê&û "À«ßïOhS“ɤ:¤@ `Ì’ÏÊÉDT«Õ …T,Õjµ pB`v(uK»l×Eš Gg£„ypOg@I§Ó1-%×…Pc_'¶…ùOi±X,Ú½Ç*‹QJè¹_l}Æ¡´f†Ý i·Ç-Ï;óY’±…•JÅÚÁ…Ãa‹Å‰.Ìו•c7y_ñÑhÔî×à³N„Ò rýpà2'Ξ=kT@öÕsšR>ºH65dKríÌ5ì;º’l0½†° Pì÷ûvmªþùžŽ½9¦9€Óq̓À›o¾Ùv¢ôÝDÍËœ]'º-X @“g¥¤]À!íj¾¼W’e¼ß±µ¥ÿ§PPPÒÌÿÏ´ö½€ŸÞ¿_±XL‹‹‹:wéÊ í€T4?©TÊâ-$Y,eEÀ"/j;áõ‘œ—×ê‘m“Âu¡|…¦À9777ÑýæT’-$”ã`dýµ&3£ :=oa%Z­–Ldžûš.°gôp†Ùô.XÀ®EŒ>0e”P‰ûD¢•B÷ ;C6ÀàÕív Ä¢\ZZÒç>÷¿êôé›%IþðÏia!¬\.§Z­6Ñ…–ÆV&@ŠY¤ÙlZ)Pˆ”vÜö€S\Æ€^ØWÀ(ì`Šïš™™1@†‰3 ׯo8*™LZ\ Áë|™vÜâ‹8^æ¿Ï¤l·ÛV¾¦U ŸK ¶‰ÍßÉû ÖÊ·œ#Ç’ùÉs ˜Å Ñï÷µoß>ë› Ã Ó ûc ƒ¨e¾y ÷Ì?6¯ÞÀÅœècäƒßT­Vµ²²b² ¤˜:èôQ©T,ç±ßïÛf¸R©X¼.f˜G~{{Û:¾\­÷ÅÅÎ;‰7ZD6ÎldyWL;ìí1-OÇ5JÀDyÆÂOYس],€0ÞçË¢´~B«„¨í Ä—×—–têºëô¦`P±z]CMRÜüÿX\Ôÿ~䈾|¥LJiƃÜ’ ¸ñÒ‡=áép ŒŽ!W/’¬¤æAùp°~~±“vKc'o®€ÀAJd 7@‹ƒ8 T¯×­y< "x˜Ø~Pèc:|?[¯÷òíò0ã…î€/L%d˜¡CóGÎ@õ£d‰Dtà ßT¥²_•JNû·ïÔ}÷}EíöަÌÏM>ÐÂÌH²²/ 68ì£)ûÖj5ÓŽÂ!‘ÀQ‹ "ÉJ¥\îàΛ‘øYÀ Ý›¯˜ŸÞÙ Ðà9ƒÅòÏ€—ò5爓ÏF£V¥ï1ì#àÀż‚Eõ@G,Ï8ïžG@5LX$1PCÌ<ç¹Ç&*IÎržiÀì2L!ÏîmÙ(•#_˜ŸŸ7ý!%|€ßož|»Dæ?Ã÷{ç.Žno&‚-fþÀ¸³!õîfŸ· °?sæÌ´¼‡Ç”œŽk0€·ß~û+æMÒ®v‰˜ŠÅÅE[¼˜a8ƒ—* £P(h~~ÞšÇÓº vM’•éøNôK,&”¯‰$![ëH„ï„€™EiaaÁî mÄø9Ï$²1ÈÐ#ÎÝÙKKKæ¾,•JÆHŒn‘2À `éÝÖ0¨>ÞÝÇÉõF£ú“?yŸNz£$écû¿Ôë5e¬V«Êd2Æ|rýG£‘ej¢ÄôÀ}¤P:˜AÒh4&b>¼Ì ÕjéСC–ç‰DT(ìóˆòNaØʇ‹‹‹¶Q¤ù8&âZD–x} Ñ»K¯ * Ú¿¿9_™;èçø=\¬>ŽÆË%|—˜jµªååeI»ì”àýôPzö]H|f( ›ëÈüÃ8†)à‘A¹”Ðò¹¹9ËÝóí‰a‘v«<{tøðRž-ØNXEæ Žåñx¬z½n:Un2™4­/ó¿X,juuÕXlΙ÷›ROÃ}K¥RêõzúÌg>3e÷ð˜À鏿áKÀž™ fv¡”Ö¼c˜ "NÈQC«‚ßÇ`Øð „o瀔vÚå%‰‰¨†Ï=äóé:"i¢t \\\T­V³rŒU$Q½^W,³˜†´ ŸÇHù+ Yp-‹/‹„×RÝÚÚ2––CÚÉu£TL ÅŠkÃâËçzí祣%¸‹/Z9æÀŽAF‡g,ÄÄiloo[GIæØäxÊÑhÔ²ðD>\œ’@'ësŸû·:uê ’¤ÿøÿOÕjEc~b±˜@~Æ€4¬ lìÊÊŠ!Zvá®…%B/¶´´¤R©dî`T»ÝV2™4} ˜$%^'[«Õ”Éd¬ü‡!'™LcH‰›2{µZµXt‚€ÈK—.™$BÚíÍ$ i}}ÝB§ äfΡ¹#›֊ϺšÝæï˜çÄùpgÞè"a1¥Ý0ež]Øf˜E*°©>e¶Ñ—ܽ™Š|F6˜¾ØùùÈsƒË;Ãë]¿’L:Ãs+É"ŠºÝ®mN|ç6]·wï6€NßÊ’^ÆŸýìg§pi x:®yPÞ¿¿¥ËÃTࣜ*ítSÀpÁKÑ—¼X)ñ°šÐvù²áphÎ|Ø:Yìûý¾•»ø}_î¦Ñ=å)GDùNÇ5O~+ÀDH0%vÁx<®×½îïT(äU­æõØc÷êïøºææÂJ!Pv¥“Âwäq£Ä} S#É´o0€\ÏT*¥f³i’§¥øÍ IDATæ-.rJ°0A^÷… 0Â^žë±¾¾®ýû÷kccÃ.ÏåÜÜœZ­–±ß¸]ý&  Úëõ‹ÅtÝuשÝn˜•dÏ Ÿïµ¼´ÝK$VâÅܸe£3G‰•ë€Y†Ÿ,ÁÂÌiE¹°°`ú?ždÜx(ï’󬹹9%‰ öE—½×2Á˜À øàÛP(dMí1¶ ‡CÕëu[d3™Œ¹*}Œ /nv㈰aË0…¸¼™À/øh‰’ɤ-V©TJ÷Þ{¯n»í6{Á£åA?åÃ…aÖF£‘>¬Ø"qðàAk±³å ,áðNUÀ 7hlmm)‹)‰L”¨Ïœ9£çž{ÎXÊå¾ãÝ`‚aI½kœ¿Ç}ZO?ý´]g¯©ôe[&Óé´î¸ãåóy­­­©×ë©T*™æÝ%%4\Ú,Ò”a/`¶|< ׎N8@1¬¥)RØŒ`7X ¹ŽÄ˜P~ä3Ñm±p¬Ûí¶eÖÁ ãºí¶—uñbJÕj^_ýêÛôÖ·>®Á`ÓJ‰0f¸(¹¶dó%â]ӉȊÃÀ#å{/“È9sûý¾=Î y†{ï33ãñ¸]W¾ƒÏ›/¡3÷`¡|éùùù ‰C0ÔùóçU­VMnÁ|ç:1è¼Ö5˜ÛøüùóÚÚÚR*•R½^·R²$Óô¼Li™ª›¨íímËì¼:’ûÂû‰w?Ïu£„*ɘGÊ«<›°Ô¼³ãñØ´«>æŠï‡½…Õ ºë®»”N§ÍÅ-I•JÅ2 1K‘”€|b0èØ±czó›ß¬f³i×'5ó%‘HØ&vÍïIö†e~ñŧ àS8×<€+++¶ðK2Ö¶í ¥Wz*v£”(aøØ@ô@LÖYŒXp\¸mL0…´®œH²3+ZU¡Åxð†Ã“² ‹0,ƱXLõzÝz¯²˜T*Ó·­¯¯ëïÿþïÍýÌÂHÙŠããü’£ÑHëëëz饗¬ [ŠƒÀë'ÉJû|ŸË‚ÉBxóú>ʇ,Ðè¿(íѶ‹x™d2i,ÁÕÄlPª#ðºV«)‘H¨R©Ø,% [ð¸Ç^KÆ}‡:~ü¢._Ψ\ÎèñÇïÓñã_R8œøÝÑhdÆÜÕ°[”õÑòó?@‚…zffF楼‡Íì¨B«é[—1¿Õh4 ‡Ãa]ºtÉú+Œ›Í¦bO`Å0¦H2Í& \’=Ͼׯ/ˆp6c<¢ßívM¢qéÒ%]¼xÑŽkyyÙÌckkkf%®lj[š«$»žjºÔloo›†2 ‹óÇâ¸9ÿÍÍMs£©óàÆ;…ëèCß‹´„MÌüü¼®»î:Ý}÷ÝÆøÂîß¿ßØu@4a`ñ¤Ín:Ö¥K—¬kŒïLEƒÍ-ï%6¼›`ÉŸ¬V«:{öìîá1€ÓqÍF•ÍfíÅÆ.×Â~€Œ¢hÊ)h×(¢×ð¦vÇ軈—¨°  èXà ˆ€]íÐônW4=´€‚1AÓ„N®ÓéÃGÙÍ—))wjÑa‘Òßh4 t²0°(ÆãqûyØ8ÂjÑ^K›-ÏÖx*ÉDâÞÔ€ƒfëàäç`n`‚Á •¸–’ìþ±X”h¯`YpAÂI»ùtÜûáph`Þ·Äâ>€ ‡CV^2@©¹ßïë–[^T¡U¥’ÓO|·Nž|BÀ¶EÈ09V˜´áp'ø ¶šk΀ÙðqƒÁ@KKKÖýEÚí LüçæÏFŠ9Ά ÷, ÐÃæˆï†ùóÆ2ð‚Á jdœ©0_ÌÑP(dŒ˜´Ó¦®,¾”‰¹ÐK×™^¯g×”@777­·4¿O\Rß …¹ÉÆù@F¨ßtöü;‰¦p:®yy1>påI²E17®T ™v”Ó`aØ`0”°3÷ÙXììÑQ"*•JƆ¡}±0 7ó¦ò½xy¢=K&“úÞïý^% Õëu{i’kF(­$+­8( ûvRDÇ`žÁ$ƒ9¼øÖT€Ý`0h Ÿ…œEöM’-n>(¢Ýn›“ÀAÛ>4’ÜO€ÇäËèïöö¶Zú@£—òì°wû>Z>v0‹ÉâبÕjÖ[° e‘dã«|ôèß«X\6cÈÛÞö¤fgCV:E F” åmÏôá\\F#ëòá³ñèÑV"ô÷  ç3/qíòQ~Ìf³|6¬H#¬žQ"GƒÁ„™¢Z­*‹éMoz“n¸áõû}mllh{{[™Lf¢-Ó½(Áãb÷‘38^éXÂ3Éys=™’,¿ ‹Q§T*M¸€™'l 9&d#—.]R2™œ0"1oíhÑ0z@Œ±s Õü<,6`›9GËÜÜœ¹¶q÷/..ªÝn[¢N`ŸÏ¸µµÓ‘Äg’zÍb«Õ²Í šg‡õ /LàS8×<€äæv ¼”Ð!±09rÄJhNg"ÈMš×ê`£XDˆ^|N)–‹¤I@Ž—ß÷NK ÖÌÌŒòù¼Nœ8¡Ÿø‰ŸP"‘йsçLðíË˾ŒÊBâN9±½w‹Â¦ Uòìƒ^fÁäï$ ‰ÇãÆ("÷yhårÙeo/åsÌ)€C\ÁOÀ Äë­`b^ …´´´d¢~ X¼µµe=¢a )Uòsh09–px§'1ÆI¡3777ÑÛàF­ŒëÁæÊÊ—Õé\¯r9«/}鄎ÿ’Æã!Êì¹\NÁ`Ðò96z¿Öëu»'d3’Cˆi âØÒÒ’Êåò·æe0“ãñNë5i·¥"z=3 Ø`“Àq286À,)tºÌçF£1Ô"‘ˆ•£‘#x×<À °Ï&d8¶8'äápØÚ XtÌuX=æ÷Ð …©óš^ŒAÌ XI6b\·n·kåYÞ) V¢fãÈùa¬`³8ÆøÎ3à¥lˆØ¨À¾ú’r"‘˜0×0·86Fî!׈÷£ïæ³µµ¥Ó§OOàSðt¼êÁâ!É´_ 0G£Q-..*—ËYŸRvî¡PÈvß¼ óù¼•¹0uPúÁáuK¼È){ÀÈIšŠ€€l‹´$[(pJ¾ýío×ÒÒ’Þô¦7éõ¯½};ö……‹„¡ÓÿMTb,<èÊ”Ua,¬°H,JùÊG£Q köƒ( "f†Çãq%“IÓD¥Óé‰4fÐ\á0ÅbÆT¢ÃÌBËBåsà|4÷•8—t:mÚ7˜K[XIÌ=¯Õj5Óëõ”Ëå ì +‡²q§‡Ãa•Ëe›'‘HD÷ßÿëØ±%í¸ƒ;-+ÓbHðŒ,®õÙlÖÇjµjצX,Ú±°ØèXØ}Q¡P0¦‰~Òobt¸ÿ¾ä kÅÆù‹Ê³Ã3177§L&cZÔR©¤Ñh¤Ë—/[°;ŸS­V Р3Åù̱±ÉÀÃfŽch4æ4ç^¦Ói…Ãa9rD'Nœ0çu.—3M$€çc&!I¦)ö2Þ/t—aÞ¥R)»¶|ß3??¯L&cïäõzÝž6X€a´°„ˆ Û°!󒑯ˆð V*s¶³¡BLJ†ÉK$Üä lÚØ8ò|MÇÞSp:®yÀ¦R)Û¹RÐI»z+^ÐårÙvÕ>"æ‹EznnΜè—ùy0‰t_„TƒÁ • ù.JS”1%ÙqæúS.÷NW#€³V«`Êçóš5ð¢ ;KŽâs-œC«Õ’$3mÀˆH»%DÀ0}q)Ý”²ÙGÕé1wðw<¢ÑhËÜÃ0Z8€¥]‡²/qzC1;°³Vf0®)Àp4Yç‘X,f×i{{ÛÀ¿Çýg®VΦˆû ÃÎ}ÙÞÞ¶phÜî›››fžXYY1SeÀ´wa³iÉd2 ƒª×ëj6›fp"ª™÷‘9Ë\’v³-kµš•ÈÑD&“I3¨PŠÇ l@F®&s—žÌ”ZëõºŠ0Å ‡CU«Ue³YE"U*z$Àöúø%ä,< Ì[ʹ£ÑH7ÜpƒZ­Ö„¾™zA_‰ üNÉCÏÑEDT¡‰%âÇ¿Ãø<6;ý~Ú ni'鏿A'£GZ †P= ?(A æcdø}´V€B²Ô`À¤ÝÌ3@% Js,Ê4XÊDè¯0sÞ8'£GªÕj©P(Ø€ƒIA ‚•ˆÅb&¸GLï £ÑHûöíS>Ÿ×åË— ² ãÞ[ZZÒúúº1Q„Y|´ ×”k™Ífm‡áÚS2œq$™Øß3*|'¥Z€ŽPŸN§3¡ÅDËå¬tŽ6ÑGSVnµZßf°@‡‰ΗÆO>NhkkK«««6ï0÷ø2*Œ#eÀÿþßÿ½ðÂë%I>ø[ZXkmmM+++ÖjËÇï09Ø1€0P{ ›˜Éd´¸¸¨b±hn]ÊÁ0hÜS®&ïƒiãü™×XK˜& À°ŽÅb:{ö¬2™ŒÆã±²Ù¬Ýcæ×`0ÐñãÇuÏ=÷H’þèþÈôŠ\ïÞõsió\Úa¿ óÆÙ CʳŽa(›ÍjccÃôm˜Jjµšm˜¤]`É»€‡ŽÔ?«^k:??o‘¼QÿT%j0‡lz½žfgwÚ&  õz=%“IµZ-c{y†F£‘é_yå{·!ga®³ÉåzøM›d6¯È˜‡¼ƒzè¡i'=<¦ àt\óð&\yˆ¯kµš•\½9‚r ;evž^3C¹Å¹dÞ\ ðQ°slF#sÒeÍ”_0ûý¾õ…µ)—Ë* Vîáø(Á„|Ñ ñ½ÕjÕzìz-æÁ` —_~yB;uµþqccCÙlV333–—æ DÌà®JøìZ­fç  \P&£•]4µë Ð¥ìF0† FSÅE._«ÕR"‘00E.q©TJ­Vˤ8¬™hÉ~„YeQÄ!KD)®R©(é„M…MJ&V«uHµÚ²þÇÿ¸[wÞùˆVWWL׉»Ï;£ÙèxæºÙlª^¯›Ô€MÁh4R¯×›`ÿ0S@¢ ˜Â96Ò3Ã\#$”—ù,ßFc†}ƒVþž™™±²?NUΟk‘N§õÝßýݺᆴ¼¼¬gžyfÂùÎv÷°o©‡V“Ø&¦$"r¼–{+FMŠÂ\%ö“¥s®·7gp/™S”L}§Ž †ÿĉŠD"*‹šhÕÈ;ùÎ3ÀÜ`cÐh4ì¸(¯§R)»—€_²þºÝ®e?ÂølïÁTæ»wÖO]À{{Làt\óú¶D^¿‡p]'/+âÖOì¶Yl`([â„UD»†FŒE@&ÉØ;XAL'|7Ÿ#ÉZUÁ|`f ¼…A‚0d/>§,„¾¥$cXhé¤@´ Ú4- Šï%ØMUÜ~ öˆc¤ÌÇï#Šç3%ã¨äç={Cd %EÀÆÎI ›œ>OÌ"|<£w‰˜Y¨øXPæ íËø=tbhŸ`Ãá°¢Ñè„ã•ÍÌk Ðí·ŸU¡S¥’ÓcÝ«“'¿ªBaÍ¥i€Ö`0°FþŸw¶ò œa·ØŒ8¼Üœ©þç¹fWÇù²´×‡I2öÑkk}'®-%|@Ÿ…cÐFù•9wöìY}å+_1 `(2F“kcì#~|<ïQì[*„Fy¶0iƒ!„ç ùÇÊÆùä7§ÃáÐôºãñØt‚ôSf~bX!rªV«Ù}ÆhâcŽ`>¹.l|9^À2-ý=aîðþ"rI ™¸ì¹ÿ0’Äú&‡õÜsÏMàÓðt\ó üº×½Î"0xùñ’DøíË(>b ñ.UÊCD,À&PæA†1å¹`0¨ c[Ð+QÚ¢4 …¬ôE÷i75Ÿ§g}|t Ÿ{EI·¥oÏ Ï ¦RÚ5~xÿ&ÉPi²k ‹7×Ý+Eñ'sss–Õ‡MÅã3=Xk·ÛƲxW©T¬T,ÉZ]AA©M'ñ:«««®>fþŽŸ8p¸°\èµüõl·ÛV†f0`•jµÚDذ—1|îsÿÖÊÁ¿þë¿­PhWWˆ| Ñhx‡MöZ4U%˜×xÉdRÕjÕ J°_ÌM6u°’¬ÿ´Ÿ÷^ CF Œ´«Sd“áûØ–ý;€r(Ì!L+ÏÇ “ss %×s8êðáÃÖW˜¬BX{ô«Ì/6‰dïñc#xêÔ)­®®šiÄo 0HùÊׯÓé¨P(Øf}!ï=þ?s…h.y~}I˜¿ÃÁýWõWÓðSðt¼êÁÂâ_²Ò®n ƒ0°C ÆŽ•Űˆ“Žïi6›NO~g0(‘H«ÀB óâóêpazPáË¥DVøXŒ ,^^ÀžL&­œ;é 8ü-°¦¾/(ý~É, ‡ÃÆÀ1B¡•t½nÀ´°° L&cýj•3`W;ŽØN)® €¦#¶ƒŒ3X&Žã‘d ÝþýûMwˆf&Ž|=Bx™c”t‰4¡Œï1%8—s¹œßt:mebÀI<W6›Õöö¶R©”]GÊÓ?þãŸ×Í7Ÿ–$ýüÏÿ{F3ÆøÂ^êK¥’ho˜g€ à’’>ó”9‡ìÀ®f¹{½ž•%ÙÏm4ª×ëª×ër8ÀI»ÝÖåË—­LŠâ]Ûhh¹®¾ïA>`fKÚ]ìƒÁ 8`L+ßÅ3âË‘t#)‹Öq––œB63þ9!J‡¼:ä‹‹‹1‹°D’Áü`#ÈF‡9K ²3s°^¯[ð÷ÒÒ’±þƒÁ@©TÊ =¸n³ÙìD«ÈV«e@íj¹\69¥zŒÞ¬B¾^.—3ð¨ö‰´dóAè²hÍÇ{I ÷Ãgoz¹€ÀJ$V~ÆAÌg°Qâ;<Èô) Ó±wÇT8×<ÐÞ~ûíöBD¿ÄËxŸù†àž’ †Ø^V’,씥 J}”0}wß&  (Ç»‚>Œ—2e,4l”Ó<˳´´¤f³©ÍÍÍ Ö=†˜4‰}{2J¿thèt:ZZZ²óäœ%ÙbŽcfÐó€›0Eû:_öâûaz½ž•¿_¥RÉJ\D‰›€æX•N§-(P3(Éz´ÒÞÒ¹ˆh¹o0¥\ËF£1—#É~â5”˜+†€vÆÂ‚c€6%O®`{aaAétZÑhTGŽÑ]w]йsQml¤ôùÏߦ·¿ý)ÅãQ‚³³»½Šq©"]@KÊ\’dó¸\.«V«)™Lè‡J$:~ü¸‚Á šÍ¦…®£íCÛʼàðÜH²çÀKjµš”dhÙT‹Å æo}}Ý6Q\”^`ˆ»Ú(@¼‹%¢……3½àÌô͸ø‰„Ο?oÔœx<®z½nº6ϪÌÐØá6ÄÝJÙ›2$ $e@ ¸X)­ÿcåîh4j&4Z\_€å2L¾ PÍ}@DOÎw^aaäÞ³˜cˆF£–ϋŬ´E· ¾ìOy”¹è£2˜7|úJØ#Î ­¯¯kvvV7Ýôœ66ò*•2úË¿¼M÷ßÿUE£‘ Ó îL2 yʸÍa¤ØèðìÀбaòL_¿ß·±Ì6Aü<çî7&0×è †”¡¾ÅŸ/ï&aûG£‘FãFÄxÙp ]¦R)ö°Ô”‹‘À„ãRç^bØÐ±9˜µ9Ç|d㨣¬ÌÆj 815˜@ˆ‚UãÚ&Ùd!é ¿0™LêÝï~·Nž<©cÇŽ)N«Ñhh}}] F¦EžÀ;Ä3–l8Ùðq/Òé´êõº‡ßÐònBj!ÉžKﮟöÞÛcªœŽW=Ðr:uJO=õ”íT}h³´ËµÛí‰rÕ‚å]Qv”d‹€w€–Ëe3y°ã&Û v çÝ ¸‰0@@ÕjÕØZ‚QZļ€â%ÌII‘ì.XÎp8'«Í&eËùùyU4ð§ð IDAT«U}ë[߲ś…’ÙüüüDÜ ?£ÓB&“1àLi ˆûA[¾«ÝÇF2÷0¼p.ÉdÒYŒ8èù9_â#K¶DÒhanÀRÚ0L>(AsßYaré´‚ò:Æ‚L&ómRƒp8lÆ6¸a‰ÞÔÀÐ0¯˜w?üâ[o=/iG¸°·Îè»`™`ÎȘËår¦)üpξ`4UµZ5³ßÏñQ¥å"׈{†–’¹By}8Ü gçy©T*¾)ûzƘyÌœÆßívU*•Œé溧R)Ë݃íeÆ •ãäYv4KKKbæla©4Îaý0VÌÌì´H£¬Ìwe³YÛŒF#åóy­®®Ú; ·2™œ0‚Í<çô%ai'N)Þik833£C‡Ù5D ÁµÍd2Êd2›Xy6Ž0Œ´‚ã]æuˆèsc±˜Ý_îǑ̻OÚÍ]޽=¦p:^õð"BЃ!Èg7ÊnšE†å8XˆáphŒ˜¤‰l0J?€"J”_c0lÞ£$íFR|,ibÌår¶p¡aJ$’d e5bÐRQ²e¡¦Ô˜Ïç­¬$ÉØ>‹s`a'äØgzyææb<Þé>3¶Ûíš@œÒ¢´ëxŸ¸h §3×–¿k6›v¼8i3™Œ¢Ñ¨ŠÅ¢†ÃÀZb*|^2,P2™´r¾øK2-"ÌG"‘Б#GlñbƒÀ5‡Ã:xð k<סC‡Fm^¡§ ƒ¦yä»™·^¸oß¾ m#ìL  –2ùOüÄô–·œ—$ýø¿_ssQ»÷TØk~·ÓéHø<U(T,´±±aæ4Ì7„þ™LFÉdRwÜq‡n¹åcª9^ÀJµZ5fiyyÙ˜U®5×ÃÀMF!ž/(Ž}Øu¼`œ¢Ñ¨iEapÙ0˜§ž£W°´a²aº€b±˜±žœ÷h´Óñ$š›×3¸Ÿï¾ûn-//ÛùF"Ó:b2j·ÛæÂÇ Äf` …T¯×'Âàiµ†©é©§žR¹\6¦Žˆ¶vß¾}†˜P6%¼·¶¶¶Œá výøÞ?°üH¶··'tšÓ±7Ç´<×<(///O,˜ ^<€8Ê_0jü7ìe¥^¯g9s;öø]~B^ˆ,zžQâ%Š~ŽÅÐGK´Z- |ˆÊØ¥§ÓiYûþ§,b£´–­Çc+¡òÒæÜÛí¶?;~I^øèæ`..|çŽÙAy·Ûý6v”2le7€åUÀ/·ÂXŒ`¶X¨‡þ‹RšN®1÷Ðw8áÜ*•Šm0 9rD·Ýv›•=‹ë5˜WЂÁÒæè曟×ÚZZ¥RF>zî»ï+ ‡w»6 WäḉüÁàAY|I޹×ë™öÕg\—ÄáÅ_4v‹yPa®ÕëuÔ=}üϰ¤‰{Ä<çùÔõûý‰Ïæ9ãwÑœ1_0— Õcs¥}#¬Z2™´®ápxBGŠ´@’R=xf¼ă8â«(òÝÍfsB+8;;kF²H$¢z½>‘é+Ê5¯×ëð0;ùPsi·“N4µ(®%›>r 1†ðüRŠŽÅbvŒlxljxŽËÜsæËîÝ1€ÓqÍèäDÀP>ñ¥+^üĆð¿’&˜%º.vÞbAñ ,¥[ôv¾Q;š1@^Ž€R:ŠÀPÀ\J2·*,ÿëY>àËK˜E H˜J»Zº@ `q&° €)‹ÒnŽ"L Ùv¼ì¯6UÐã@3‡>Ôƒô™ž¥ÚØØ0Æ%‹éo|£ …‚ªÕªÏ4a"ˆD"V \Õj5Y›››Öj<7X3Žý­øØ °‰Çãj·ÛZ^^–´Ã’,//+Nëï|§m\n&<™LZ©Ö3;èÌpô¶ÛmÕj5ëÇ|Ë-/êâŤÊå¬}ôÝÿ“ÚÜì`‚IeÓÀ=¡,Z¯×í\p¢’ǾŽy°...ª\.«X,NH®fã¸>äúðgIv,€Ø^/qÀ°‚TÇ4sŒÑhÔæ àž{OǤ:îæ™ .˜³ØGÐ4›M­­­i8êܹsV2†™‡*—Ë€Ÿy܆Ìår×þ}ïûc;ö’$é—~éç5ΨH²ùãNZ«I²c¼—J%cŒ¹÷p`çƒÞ lr?}îs³‡T<7Y÷!‰˜AÃoÀ‚Á åJ»%Î…{ÈæÎÏiÌt%!O‘R0qS^B‚¼ƒMÀ†ÍÏÈJ¤ÝX˜]4ªKKKZ]]µØ”x¥›nÚ¿þë¿¢ÍÍms=—J%cœ`xffvÛ«ùM€ÙÙYíß¿_³³³¦ëâ~ðð\á¸eƒÃ3è58@q¤§ÓiÝzë­ºþúë Èr=*•Š1É<l-ÑhÔ€× ;ŽÑK:ŽI&*•ŠåâЯ×ëÆÀó¬w:Á°nÕju"–‰yÌùñótÂåä9¥ÚÀ&… ÁçT(0îÀÎÃ’zù SÚuã3ŸÙlñ|^Çã±Òé´é!Ñ2×ùlLMlfèÕ ˆô]IÈHÅx£-ɤln¦cïŽ)œŽW=|ïXØå i7n„VÊŠ>Úb{{ÛDæ¼ì–––T¯× ñ»|–ݽµ¥üéÓ& ´Pþ;ffv:ƒA …tÏp¨à—$.L2Ó(YÁ.;-Ü`{½žÖ××-y~~^ï{ßûtýõ×OD.x#`Ø/ò,Ö€HwR,U«Õ´¾¾nÙdù%Ù‚ÅÇU«ÕÌÑûÈBˆ]XXÐòò²*•Š0¨)UÁPšN$É/”vû&ã]YY±øÊ™RX+•ŠÖ××-šr¶wt{ƒ¥pI&ܬ£ÑÈÊwñxÜÀ+ì. ,îùóçõâ‹/N´ äqÿ”ÍfmC¡ëÉâââÄ5 …BÖ5ä}ïû=ºÓ6î—~éçÕíî¶Ï# öàDGJuƒÁ@étZ[[[Æ`s])ĹŽãñx­ÎýÆÈ‚ó#7 dHzÖ5ÛæŠ€v¯Óëõz–ñÉù¡„åc×h4ŒO§ÓQ’N§-÷’øÞ-lrh¡PÈì™™ÛLÂ,“ÀÆ -àÕÒ¼·|[@XxÞa0mDava~¦‘M°‘D²@ìv»Ú·oŸ}Ç»±±¡áphŽàP(diº‡ gñ•ô¹È6øýR©d®mæ ,o.—3# éØÛcªœŽkhs¹œ€-Ú@(gàvôíü9°èl^ô>¶£X,jnnÎJ:”#7ææ4u2P¯ßWùJ™ï÷aÊìÒOH:>èoÆc=1³Ûš 0»hcQ>zô¨Nœ8¡­­-½üòËV¾Ì^¸pA—.]26ÆëaÅp|6è¢XTXàY,XÌXè|‰– ‡1Œ¥8ZiòJHʸ¸4Y´è†(¥‹+]?8/Iv\\.þ4›M+‹Q†¯×ë’vM<ãñXÙlÖéX,¦l6keA ¾ô ñ®p_.ô¥b´R Ì/Œ%,±'€Ø;æ-.UÜÁÃáÐJò·ß~FkkYU*Y=öØ[uâÄãvØ4_B¤ì ` ³T«ÕìÜ|,‹—EðÇ÷²æzû(%Œ@/^4C s9÷˜û'i"m/-6?€*À-îUožòî÷P(dšDþøäs(R©T2×¹okÇóƒOÙU’¹ÈÑB¸y¾qÕzó š[ú˜{³ºfÊÜFCÑhÔŽƒg6 ¼›||ÚPIða; žñx¼“Ó¸±±aL<›)Ø}þžû…†ñ¹çž›j÷ð˜2€¯Áñøãëû¿ÿûµ²²¢@  ?ÿó?Ÿø÷íím}ìcÓÊÊŠ"‘ˆNž<©çž{nâgjµšÞÿþ÷++ëýï¿-Âßéà…ÈËW»Vv߸Ü+ÞHy);lI¶0RFI&“&’Ç=øw‘ˆtrfF·\)űËG,ŽãﻆC ô׃^¸ÂЂÒs4µø *°§NÒåË—­Ç(¡p8¬W^yE•JÅ+$fß/ã‘,ÍñAé`A6à²,%U´~±XÌX„ÍÍM++Q¦«V«Ö‰íQ(h½¸'°…×]wŽ;6Vë>ñ4ˆö}À7 PàADÀºxñ¢Åòp Çã±VVVŒY‚1öL*îGÏ 8pÀî@f}}Ý¡Òn‹¬J¥b l­VSµZ5ÓÉêꪯ·¿ýí:tèêõºÖ××Õívµ°°`s gt&“±k¿¶¶f%lßâ’wïâ⢪Õê5½ï§ã_ϘÀ×àèt:ºå–[ô‰O|âý÷_ûµ_ÓoþæoêŸø„¾þõ¯kyyYïxÇ;&‚?äG~DO?ý´¾øÅ/ê‹_ü¢ž~úi½ÿý₩ã¡ñ¼ogÄN—Å —#;e"Ð ±ÀÃz±+fACKG™–‰wc~^_ž™Ñ½ÛÛú®áp‚%b¼g{[oõµÙY}+3Ç)'J¾d‹~B¡2™ŒÎž=«§žzJëëë¦[C‡6 –I’i“øo^þŽÝwÍ@œÎï¾(ýúˆ›`0¨r¹,IÖ"ÌßXAIV~ÌÐ`Ö8X#@¦gÙÆã±ÎŸ?¯3gÎè…^$[PøI¸1 ‘#\×k q[Â,ÂXøò*Ò30{ÌæÜh42Á»4©+\°ãúæó<«¶¹¹i ‰Rp&“1æšïSª-•Jêv»úÁüoºþúoIڡЛ´±±aûáA÷V Mâúúºßy†œ»L&c›’l6k¥ÂñxlesSÀ2s Cy™²ï`0°2&ó‚ò²$•Ëe‹#b&æ Mj½^7†Ìkh™ëÄüH»f&:‘ðÝ#Òé´R©”1Åè]Ëå²`qôÆe\*€HÞÏ×ç© ÚZZöy¦N7bŸ¿´Å‹Åbv¥ÖþàÁƒ:yò¤r¹œ‰„éf™‹0¸¼+a^¹¿Ì«X,¦x<®ÍÍMc ‘ LÇÞmxçéxMŽ@  ?û³?Ó< i‡ý[YYÑÏþìÏêñ%í0tù|^>ø >ðè…^ÐÞð=ù䓺뮻$IO>ù¤î¾ûn½øâ‹ºñÆÿEßÝl6ÇuìØ1[T},l–w(zá{(²ÅŸ!½aÇã±Îí ;Yœ´žáǺg{[÷noë‰PHO\)ÍÏÏëîÑH'F#}yfF_vz7%ÄÙõzÝ^’”S b¦é™i¬½®V 9z¬™™•J%3Z°»‡5Á*—ËÖÒŠÏEIÉ‹ë 4ŽÇcs+RÚæ8$Ù¢ŒhŸpeSÌ”°ùNZ؈~¿oÞõz]ù|^NGÍfs¢ÕçåMÒ¤3Wéüü¼äp8lÞµpx§{ÂüüN[½|>oçXƒ¥| › ÃDÆaiˆÚ·oŸU`­Ð„1Ч<èFQ­Võ_ÿë:sæM’¤_ø…_Òöö–¹fëõºŠÅ¢Å 'ûœ#‰ØÜgcÐét¬gv&“±MºC4q’,J'ŸÏ8ÀñÍ=êõz¦Ÿƒ d."Kh6›J$jµZÜý÷Ö+”·)ŸœaÅ™»Á`P×_½Âá°Î;g×"ÛÆquuUµZÍÊɾÔOyš2?ºX˜@úbsÝx–|@NE8&Î6Ù_œètžaÃug3AéžyžH$ŒÝ÷ÏA*•26š;ï@¤!>Þw#’4‹… ‹gýÓŸþ´†õmžŽ½5¦ ࿲qîÜ9 }Ï÷|ýÝÜÜœî»ï>}õ«_•$}ík_S<7ð'Ißõ]ߥxÑq€xÀÈp¸Ó=&5•J)‘HØñõû}cëB¡’ɤ¹zé ëÙžL&£¥¥%% mnnš¹C’9*YlK¥’:Ž.\¸`ÀV‰…’9T¯×5??¯L&cÏÌêêªöíÛgúAJdÎ]¾|YÅbÑÀZ«Õ2z±­­-ÓÜýðÿ‰Ž{Q’ôk¿ö+ dG|^å{Ø0Ib···•N§%ÉÊÞl¦Ø,ôë’ìZ¢Qcß™`uuUwÞy§–——­ìŽ sdiiIñxÜôr€ ÑÈ Ð² @‰DªÝnWívÛ6x0õ‹‹‹j4J¥Rzàtã7‹GË5æl< (1QŸŸøû|>oÿV(”Ëå¾íws¹œýÌ?6677Õl6'þH²:À /A€»fÊh‚X´)˱èƒAÕëu+µÇ;½€Ù‰óFŸ„q{{[_¾ÂÞÕïë··urfF_›Õ—®F&@D’P@+ !Åô½¥dÌ¢Ké–Eý ÊŽœEŽÜ;a`B}çßnK’15/,"Ï+++V† X°°‚î¹g€>ßžàE9—ûóÅϲXr}1¹ÀHÐQ9›C°ïÆÆ†éÑ:Q†Ìf³¶@Fg>Ÿ7 Ç}šµ’:%xJ¸0¾¦† C¥RQ(²ëÍ&Èõ¢¤ èv»ú7ÿæuøðÓ’¤ííÜD˜5L2lòxZ“1*ŒF#c«)2´C›™™Ñô¶·½M÷ÝwŸÞð†7L”œÑ+ Ú×løè5a‚½6vú7âf0 ùÈ’­­-­¯¯«T*éòåËÆzq-è›ÌFˆgš˜"ž!6ž>þ…ã¢; W2.™G¹\ÎòyOaÔÀTåYAÏbò,ˆàÄJƒA3ñŽðm5»ÝîD¶"s½Ýn+N+›ÍZV"Ï÷q8š“™ê „Ó±·GèŸÿ‘éx-vë Ê ÿÔ¿ÿc?sõøøÇ?®_þå_þ¶¿g‡É¶ Q;,Ú’Œùƒ=I¥RöÿyY²öq.”ûF£‘‰„æççuñâÅ Ý`ð)Iw  JúŠvuläÑlžd"‘°c&Nƒã†Á@sF¸+``ëõ„è™Ð²ÁŒ‰ÂKxaaÁbÐ3¡ñbGOÉ 1y2™´ëO,ÍÜÜœ¹J/_¾l] `0šÍ¦`çÈr£TEYWÚe™Û|%bÀ#ÌL*•26 5 ©Z­ZÛ*Î×3 ¶//rͰ”ŽçæætæÌËaL$êt:–™¨P{V 0 ¸ìv»j6›ºþúëU«Õ,ãσ°x(Iºûî»Õh4ô·û·ºóÎ;%IO=õ”†Ž?þO~6 ÈÕw&»Nt>•JÅŒ^T”J|ˆ¬f7M+'¢0Æã±-~¼ày)®¼Ñh¤›j5…ô˜¤¯ÎÌè­€NŒF6›úúmw³Ò’Ž IDAT^êƒâñ¸…ä"¶FW*•T«Õ¬e™*Á@Â.ö“R5@΋ë%™çÃ}YF£‘½¼ Göyj’¬7/€&í$ T«Õ PRr¥|]¯×µ¼¼lnEæ×€øõ%oX5%K²Ïp…Ò3•Ïã¼p.ÎÍÍ©T*HÈf³f¢4é[hÅb1mmmY;¬T*e&2$ž”å¯n›à›ð ^Ú ÷ýt}¯W+ ’sá˜)Ýq]‰òàº:'S’;@„ Uܰ¾¯í¥K—ìY…ÍÂ9þì³ÏËY‚àe6uäùùî=DÂÐÇÇ¥R){ápxÂës/¹þFÃØÜX,fi+à†®^¯[i› %åRîÀ“ç  ™3›wï ¹\Nß÷}ß§ .XHúh4R6›µg(¦HÚaÕÚí¶Í=ßC{8Ümç™çÏ~ö³ÚÙ\ÁøSºE×'íTLÈãl6›¶¹CP,4’½zôèQ;vL§OŸ¶ò/²“éØÛcýív[Ï?ÿ¼ …‚~ï÷~OwÝu—½¸‰„F£‘>þñëÆoÔh4ÒÏýÜÏéòåËúýßÿ}ÍÍÍ)›Íê©§žÒþáê-oy‹.]º¤ŸüÉŸÔwÞ©øÃÿâã šÞ£hØ(—I»`ŽVe,Ž8,}|†´»¨òbçÅ ûÄK=›×h±Û?>ëþ™=:êﯔ2_ÞÚR0Ò½Ú1—œÊç³÷+xY’;'É„ÛÄu â%Ë¢—J¥Ìø‚æÈ<£ÓòYn,à,ød-¢çØH²N ’l óÏ»yaoÐ`qL’¬„M—Œ×—QÞæï›Ì9±àÆãq]¼xÑ@( ¥5X\Ñh*:”«ÑÛ1ïÒS†Çã¶)è÷û87ËAÌ ¥at{8pùn®;Ìsàj¨Ë=¹P27ûý¾R©”ý›ï̵Ãð#ÉL?hZ™ëèÙ:Ü@%M$h…ˆ“ 4ƒÎŠƒÈ€@ `0-Š]À 1ïtÏ $ŠöI’®»´ÛuÆ f–V«‚qº_°Ø±pø±¸ ûý¾r¹œ9—Ñ(Âr,VîT*¥N§£µµ5Õj5c `¦ÐÒÕP”Ëå 1Á.VÜà°Ñ„bÃŽHÿsÌ„ëz¶8À.Ý>ȧƒYFóÈ<‘dçÂE ›P …BÖ—xX*î z;i8 eãC+1ßÚÌ?g«««v¯h‰çÍ4NG£ÑÈÌO@sÏçÚ¡U„­åyÁq @LÄ  “ȵõ_îo·ÛÕÊÊŠªÕêD¦$“ k¤d ƒ»¹¹©b±¨f³9–ÍýÄDñˆ{èÂÌCÙÀMÔ6¾ºò~ðâØÏçóáó+++:{ö¬½ë–––T(&ìù¾F£aïF±X´–•°‡H¦cïŽiàt\ó ðöÛo·Ý; š02¬pùa²€ÅÃ!ȔŊr);srêX0š$ ½©ÙÔ}’“ôÅ+ì—oþŽþêd(¤ãƒž…ô¸c{`XØ5ÃÁ¦°àdÐÔ0‡àÎ¥ôç39o¯û[ZZ²H¹áph€´\.[é³Z­Nèé„ÂRr£léËu²x<.IV‚†IcŽÇã7P'(7›ÍZŸaDë o«Õ2BÙ™Ò:,@/ Üí·ß®d2©/|á Šñ…Α{º¹¹iynÉdR­VKñxÜæ%ºE¬}„ýDÒl èdÀžH Ïô!þ§Üǵ±±aÚU®@ Ó¸#;‘8›t…Ø`ù’x£Ñ°ÿ€ëP†ÉL¬­­Y©9›Íàb.9Òl6 tÅhƒõâZyÆ–y ¨ªT*Êår-Éô„”Ôq®ñD¶!€ óÙ`00I;ÌR“r¹l×3[*L'q,¼§(¯#ñºWÞKh)ÅÂÎÏÏkccC¡PÈô£½^Oív[™LFNÇÜÀ¾¬_¯×•Ëå&Â¥/^¼¨ååe›—ñxÜÞlØxø˜,®'×wœ7­µZ-ýå_þå4p© d:^õ`÷ PvÝ£èfhÍÛ@”H"‘Ð 7Ü 7¼á æä“v#Oa”Ð$Ø‚% …Bº­×Ó}’ôÄ•rˆ@#·´´¤§Âa}yfF÷ ‡ºû àÄÍCósIi”;e6^Ø‹‹‹¦Cô‚pIÆøyñ6lçÈßÁ:ˆ†•“a[Ȥ“vvþ‹‹‹J&“ÚÚÚR:¶Ü4S«óù¼1yý~_/^4–…Ï…5€ŒD"Ú·oŸ¤Í"e'Iv}½idkkKÙlÖà~¿¯d2iF"\½±±aí©Ž?®ãÇëèÑ£ŠF£vn0R48&€&‰’9ºJæèââ¢i©È£ôæ‰H$¢••ëxQ.—-'R’™"|N HÚÍ°ÜØØ°>µÌAâD(M(eSZ…B6‡xžŒ’LßH§@0 3‰X!%\Ø&À!Ý(þ¿öÎ=HÒò,û×ÌtϹÏ=Ý3;³»Y ‡ K”(R³HÔ*+FB’Ò?ÄHR¥AcM¡Ê(«L¬¤¬üaTâ*cŒš%ʸ",,Ç=ÎÌöù03;==3ï÷ÇäwÏÓK¾O`IX¿¾¯ª-ØÙžî~Ÿ÷yŸçz®ûºï{||܈ï‡õLqT4ê>òœ¢ú2wÈdÅ Kè“ÈþGH+áùЧˆ"‹"–j|JêéœúwÃ:žŒi,³H‚§`7÷Œë íÁÁAS ¹ôHÚ «H[jîÔÔ”­e§OŸV½^·Œ{žo>ƒ YÑ$­­­©P(˜*Ë3ÉÁ­ÑhØú“ÉdŒÌ2>Y‹ù}øÃÖÁƒ­= ŠJH䢬«««zÛúº~JÒ¿onê?¿§FV¦h/!G²jïu×jµÓÑÂ÷T96Ôpã•d†z”IÈS"‘è)]CÕ åÏ ^)IFâïA É %‰$LX¶É£~ŸÕù矯J¥ba:¼¡l¶,þ„FFFló‡@)ƒfžR.†P1åaxˆaQT^Æ5„'jYŽxÙ¼:ÔSìYRÏÜ»™@°ÃR0”Õ€à èÈ‘#F:(4>::jÝJo2^ÔÕ;³«ÿFi’tH€<…‡ž+®¸ÂµZMVë2T‚(ƒ$Éîdj||\ÕjÕnBŸ)$9 áÁsÉ5A–Â0!j¶ F mæÎÒÒ’*;*:Ê?Ï,d‘C5[­–XxÆC"I\c ñ'Y†¹šÉdŒ J[EÉ90Aؘÿ¥RÉ"„i9°Œk||\FÃæ"剰Pƒ‘lk,£££–ÝLå2Q”sˆÉe¬‹a=ÃÐ{Ê|â Ã<ÃKt„ï‚?;Êòò²e!ã»~á…ÜØÇpèxÍ€îÞ½Û«,Æ5ÔŒ°·&á$6Óååe=óÌ3:vì˜äQðð#…!|_¨ˆ»£H‡;=ú½òlVdº–$“RSw}]#ñ¸Žj»b¸8S¢DÚöÑA8ÅÙâÊ‘¢@˜)Ë{RÛ%äeeeECCC=uI´ ëB ñðEQ¤R©dïG®$#¯„QÆÆÆ4??oµ! étÚê›±)1viJö ²‰Œ*¶#KZ’)tår¹§õIÏ=÷œõ9æ³666¬Ü 9È+$€Ö€¨D¨º„mÃ-ü?YݨÕæ>RŠ„04«(zÌŸ‘‘óºI²º•'Nœ0ÕŠ8¡y L£*2Qv3Cdð½ò~À$™ê™ËåìŽÁÚÚšOBÞÌO”Yˆ0þÌB¡ R©dÏÒÜÜ\ÏØPö¥Â6::ªL&£¥¥%#Ó¨p\7¹X—“”%m©Ç@ 6’L ä°ÈóšÍfÕl6mîBšøûÊÊŠ …‚5å’ÃüŒ×bÏ3Äá“„Æ—ù‡ÿ2‘H¨V«™ª‹Ÿ˜ vÖ3Öž‡Ø³„‡IßJ8ìðÝGFFôôÓO;ìc¸ì8kœÙØ)ÜTwá U¡v»­çž{®§ìDÚa±”¶Ë@ðoƒƒƒúÏ¡!ÊåÌèqbsÃÅFBè¶Ýnë?ôø÷j”ñþ¨˜ÓQ+!gårÙ6¼D"aŠá̰”G2™4_„‡M„pXØÿ˜ä”!ʱ´Z-#®ÎOŸ>m›'™k‰rXv†Þ±Ò–9¿Ýn+›ÍªÕjYÑ^Ô|Uø766¬^¨(ñ: î9É@xžÂ¬iiˆZfWRdyyYÕjÕˆc )£½ÆvIæµâ ¢…߯R©˜S’…òQfÙìVÆkccò¹v!ÂŽV«eöi«t ÅÃú…•JÅÌûô'¦ BçÌyÔ$î=sˆ‚ãÜ¿P‰³a! $ AÎPš(®‹mwÖïóÎ;ÏÞ§ÙlZg”09;¡qæ„ÅŠ×AŽè\y%Û™u„9aqq±ÇÛHË4È9*¡¤žn%„ày¬1á3ÄëC_öƒÐÿªæ<¬1¨ÊaRÍ(Ä(­XöìÙ£b±hmÌ+Ë2—ËinnÎÖ’:W’cÂCßwuuÕ[Á9\t¼v ‹ES¦XÌXlÂì7HNñÏàBÑ#ÄÆ@ÈÓ7ê!*…XìOˆÉ"üN˜ÉBJ¦+‰$O@–Â23ø¤X¼Ù$ `œ¬QFð… ¨D„•Ï „æp|ZúÙdðI¡˜@Œ1¨3ö¡Ú‰@A‰ >!a*~?›Í*‘HX/[p<7™·$h@òPŸ¡G’p8Ò ”cJ} ÄP†Ó¸?a86Y·Š…£¬ 3vÜ÷´áƒ ½_ÔÎët:V¯_Y·ÛU³Ù4e•’0FCËËËJ$æãžSc@z°6Ôj5ˈ†d°y3GIˆ"ÍœcpŸÃ¢Ç$Hq£Ñ°g—Cß‹guxxXÏ?ÿ¼%‰P¾…g’ûÉ}Ú²þOŸ>m¾?îvˆðÄtøðaWû®:΄U¤-E¥R©˜O†:f„w–——U¯×µ²²b›Ù²?*Di+}è‰B… Ã1˜é!P(3¨MÒv¶1*U¸…›E¨‚°QŠ‚R!,ðx²ø~göÚ¤l› Jm™Kâí!¼Ëw|†Æxüwß0òJx •VÚR5 laé6jÂ’ÜGTUT”0J²@ñG¦R)K¢¨×ëŠÃ099ió±&œÌ=’ÔS¯k†¬j„¼I²±%viiÉ”Âs¨oo%²ÊgP`š9Ùh4¬ŒPH¼ •w:år9 BêI8"óâ ¡ƒÜQ>§Óé¨Z­Ú¸‡‡¼wpjr/‰„eßó;øGQ±Pô¸—L–——­]Y»ÝÖÎ;599iƒÃФž ’ȢŧÆágäö0”I)æ4óU Ê1J÷ž9©m’tìØ1ËæPÃ5q€;}ú´%Z4›M› áØpÈX__·„)’ ÂJ`X7°MŒkzzÚ~ÂJÒarÖDæá\ ÷¼ç=ºè¢‹”ÏçípH‘ÔÓ‰†C ki8ÿý '€Ž³¡Ïv»m½(£(R»ÝîÉ Dq ç*-P§XÜÆ'_Â…µñD…$A’²Ð3Æ(mg*Ÿ™‰+m-ž(0xÿ0ÅS ¹T*Ùß%قȱ‘ó¹$Š $°g³Y¥Óik_FÙ6T~†B%™ªÀF»¼¼¬F£a õ 766477§B¡ÐãÇ„$“qJXŒ„ŒV«¥r¹¬t:­|>ß³¡A)¡I@­ƒt­¬¬(“Éh||\ÉdR¥RɈ~XZEÚ£¢Æ¦“d‰$ÏÐÕ$ô÷‘tL&U,‹Å477gs…páb@* ë6›M+ù!À_ˆï{ƒ'R8”¨Ac~@2ÂNaÈ:Ì(ÅׯA)¬ GApæ.Š#j%ß‹°c½^W·Ûµp"álŠj“éÊÁ% 2Ç÷àúx^zÔ²jµªjµÚc‘àÚð¹ñ< ”rß ­W*MNN*—ËÙüD9ãàÙA5ç€!ä0€ª § ï 9 ìææ¦uf‘¶Bçøe!fù|ÞTsÖ%ºÝp¹NB»<3¨Ïp²~)ÃÖçCI } £££šŸŸ×?üÃ?èŸÿùŸõä“OY%Ü/Éß(Šì Â:wô/¼´ã¬ÁN«3ëd:¥Ô$ó`…Å€Ér ;)„áÅÍÍí¶\áç•Ô£öðïx¯0`B “,ØÌëõºyŠð¢ªA ðÓ„™›œÞÙ|Pà xáHNÉmè÷K¥R=Ù“lL­VËH!!è° …´­`¬GM “xÄåennÎ<]¼†’¢ÕYBú¥RɈaXž†p>¤’‡êHÈ™Ô|g(©aœ2#’¬hs>Ÿ·û:==m­Ì)²—¥íŽ%ˆóò)a'æ/JI¨`ñx\¥RÉÚùQ1,ß24´ÝF0T¸Cµ7 yâCÌçó:qâ„ÕK„Ì‘–ü€ ‡¥|P©! étÚ"þ<æ8aJ’[r¹œ•-‘dãÈw §T*©P(XÈ8ôïá $Kõ ¥•z’x|†ÕE™°™(g$N¡sX ÀßÃÃR<7ÿ`Xø›¹aÃrBùæÞòò²¦§§Õjµ499©Z­¦‰‰ ‹HÌÏÏÛÁéL‹é¢B9'žÙÐv144¤r¹l‡\ˆ>^NêdkaaÁj9...ÚúV0¨×ëæù¤„Åöñˆ:ú®:΄Á°àÖŠÅbæÓk6›=ÄLRÏBDµðÿ!DømÈD…\= a#”ˆÊg@0PŸè€‚Ñ ½nxt =jµZv]xœ t-žžž6Ä!‘Hصv¤%Y>Ÿ7’f BD2™Œ¶&ä¡Ã‹ÈÆ…ÁÂ[.—Õl6MEE…]\\´0m蕤0—ããã–ý)ÉÔBOívÛ|_ûÍÍMS$÷¨òß0)dccÃÂá¼µýãÙL¥RÖKV’©šív»§œ$šp5¯ˆË}/‰(œ«¡"M"æyæóŸCÂÃa96f„#§¦¦lþ£ŠSFi~~Þ>ƒð0äIÚî4·? ‡›X,¦R©dãÉóDH2ÄsÃü!;2És×ívU©TŒ¤B$Q“ ?3B…wllLµZ­§Ço˜¹ I"±‡p,åˆ[£öñ\óA²ég Ù ûhK²u âÅ3N¨µòJÑsj ¦ÓiS@777Í+K‰ÚÎ1Gƒs¢ÔãÃzFƒc‡e‚p÷³Ï>«ÅÅE /‡‡©±±15›MSè¹·øp‹Å¢×t8tœ=8-³ÙAì !üxª0»ÿ²Pñ~ÙlÖ6 ŠÆ‹E«ÜÏ)?$MþÙ ”’°Ô uÀSƒ 5'NÛg’Á«#mg'CQ<%aD—d›&IøÊP!}„˜ðÖëuó9²¨‡†sÊÓ°AàðÎ{qm´â¢»‡p›Y»Ý¶lNº'&ÅÛ™Ïç5<0ºy0F¨Í£££ªV«=ž7$¨A„D©YIÍ:Teê¹A±0ÇPZQ|ñ+âk#4'm'-A4˜{¨BC<‡„€™øÁb±­ÆÌ9T.Þ¢ Y!ñ‚à ÷0:¥h$™N85¬CIMÃ0k—z{£££=Ý|FFFzH;DŒñf3(E‚e„ ò|>¯J¥bE©ùŽívÛ”IB¦(‘„oIî¡ØaÞN§cªÞ,Ê­ Bdb±˜eXBVÉšMï¼RSSSöýÂLß0L…â É›;!LîE±X´Úu”ó!Lùê AóºX,¦b±hárÂõkÂø¡Šªclꄹ ¬ñx\ÓÓÓnç’,†É!Ê´’ÛÜÜ´ð1**!v’677­C‰$¥Ói+©ƒÁÿرcæcM§Ó¦l±ñ£JÆãqU«Uår9+»BhÝêêª)^Œµ !2lü¡’Éá‚ÄóÇ{, Ì[æ'v¾3ãD ÏŠ:ö ú2S&å‰1,•Jš››SµZµ(׊êÌsV.—Í3(m{çxþ8¨qÍ3®wccCÕjÕ²x<3™Œ‘7þÒBÔÖ¤ð:>Nì„L gCV¬„J.—³•ðxyî¥íC2ó‰ÄD´½ƒäMLLXé*BІ°TØa"«Ýn«P(¨\.›B me‚ÒÓ>á4Âuxþêõºy”HR´k&œLÔ Õëu )›Íjaa¡ÇáDɃ áû ý`¨˜NÇŠétÚHEŽM§ÓVPš$_’uà@’dߟpõ©S§ì=ëõºÞ å u s>Êß‚9< žCvÉø ¥¯®®j~~^ºøâ‹í}Âlö{ï½Wó7cã<<}Ú|<¨Ýn× (†vLâÙlÖ|Oƒƒƒæ‹bà÷“ɤeÛÒ™ ,MBf7Ê¡'¾ãŠZÅ5çr¹ž‚ÁøÑð˜î爇 õcmmÍÂïø¸ºl¾lt„·1òSÔ˜äÂ###VóŒM Ò^Å‚!ÇÔ“dž&”J• ©X,jbbB‡6ŸIá!uqzzÚºTPœ¸ÑhXB$ 7 3¾ )—Ë©\.+›ÍÚ†Š²zâÄ S×P  IÖù%…±å€ÚÈ××·:±,..j×®]=ïCaqÔn2<±0@† ƒ¨o$ZT*mnn•¸Ñ›ßüf]~ùå:ÿüóõÈ#Q´ñ âÃ+•JV&#Å 2Ìýâ@Âsa!Áóœ$3¢Hx!Á‡kæ Ö(ä0Öž$9)$ä$DzÕ{žÈ|¡PБ#G¬SeŒè…‹ÅìÉAyÈ&¬µöU†ôB2IFŸ É$Ã>™LZb eˆÚí¶…“WÖH1µ:)¾Î¡’Cß›hÞ0™Ã'8<ì8k´Z- mqòG¥ )ƒ¿C‚†††T*•¬˜0‹‹!-¼]á)šÍ ƒ? ·ÛU£Ñ0¿å*rcQ&l‚LÖ!^ƒ‚ñ†’¼E(ÌŒ%Ã/•J©Ñh˜ïe*ãær9#Kø’ºÝ®eG£xA:1ý£ÎÔëõžšcl ( ³³³ššš²±(‹²vfÓÓÓ¶¡AVQèð©á»ët:ªT*ò%ôL"P3­R©dÅ¥!ï›››Z]]µÚŒ(”¨S•JÅH>¡èr¹lAÈ %‹“ŸI[d´\.é “ˆD˜¹F8S’Ý+’ $Ô„âñ¸fffÌ·ªÀ„^ZZ2Ë¡:ÔÆŠŽ¡ÞjµŒŒ-..ê;ßù޾õ­oõòF‘"”a+ ¦|†¯V«zá…Ôh4¬4^\TL¸>ÂN¸ÉdÒ|’tô äRX«Œk²ˆQÝieFñôF£aܰkD&›Íö$|áËd®à—D%£P7¡y¼tüá™æ€” À ¡fޱ¦ ˜“èÂA÷ÊåröoøðHòÔs$±†CsˆgŒ¢àüŒä&Â÷¡õZørIrô7œ:^°éFãÊfB؇&òxîXˆµpÒ%¼K˜p``ÀúqR<•Ò$aÂăÓ3„ õQÚîKbF!e6át:m's~— ",²ÊfI…T°Y¢±ÑâDÑdƒE)ba§µa6CB°Œ;cˆú )^]]µ›ùùùžìa6T9PPBŽör²P•J¥R¶q±QI[E¼!Ç$H£Va¨6QFƒë†´’˜ƒ 800`žABaÔec|!A¼ê aÂ(ЬanjJ²¹K"~¿°« ‰+ŒäœùÁØA¼9„sU‰{ Ág 9Ã㊥ “É(™LªV«é»ßý®þõ_ÿU´LÞN§cjQ<·zŒ9áQÊ¥¤Ói«ÏÇ}äþBØP ³Ù¬)dÓsƒ¤2'ÍöQ­VMyÃÂ033Ó“ðùbŒQiUÈs*Ùç¾  ¢BRÓ“ûÇu”P-JpXš†yˆ÷“¬i¾[¥R±š¦¬$‚Õj5»FHãKhwqqQ’ì=‰@p CåãYg\)âÁg~Bòù>ø7‰„vïÞÝ“Œ†€ùçè_8tœ5BSsØå!ôÑT*¥ÉÉI#*NÄ›››¶è¢èPp7$%+Ь†ïƒâY › " !a#B’$z´ÛmÛ˜Y|ñÒaòFÍ ‹ß¢LNMMYÙˆ›¥\ ^C’ˆû¡6’Lœ ˆ9ªçÈȈ•ÛaCÖ8z“PÄ—––”Ëå”Ëåì¹bn‘@E("µy¾˜„) ƒ¿sïÞ½š5 ªŽ|>ßcw8~ü¸ ˆ)ÏýeOŸ>­z½n¥Ob±˜ÍTUê=òü¢8¯¬¬XÈ™Z„’z¢•JÅ>+<¬AŒKÈ j|7ä+“x@bÃëg#˜˜Ð‚m‚ü5“ºá¦’[I–µªk›››=5ÿøÜ  SL¸ï(:>”`TÇùùyK‚ I 2Ž‚˜ºƒl†µxâèÝËÏ8(àc6eŠÒ>áœÁÓ&ˆLEˆ‘gG’•´ADe ³x«Õª…%™÷“““Vd˜úŒ¡2ÆwÅëÆ½àzsÅJ¥bv ”/ºþà™™™1n.—ÓÉ“'­t Ï4ár|¤Òv!øÐ7<11¡§Ÿ~Z…BÁËËËæ…ì-èt:ÖN„“°­ªìéÓ§5==m*öââ¢ùCŸ*ágêP2Y« ¤’L„˜sÐà9K&“F²90†-éÂg‹Ãt:6Ë Q¼¤ñx\™LÆÊpñ,“L‰›f³ißûŸþéŸÔl6-kÞÑ_ð20Ž× ÊÀd³YÛ¸ ,°###–9Çï ° ± ³ ·ŽbA'K7ìœ—Ž°)ïAæ_è ø|áQi« œøÃΨ‹„½ÙœÙ¸¥íž¨¡› 2@V !XNý|ÏpÃGMAñ„h ¶‘ 088hD`mmMÅbÑÔ—0ôÎý ÂBŠäG~DµZÍ:Ÿ‹Z…JA¨Œ$/A øÄÁÁAS ÃÖm>’X ›ü?uúÂïÏ}:uê”mæ.(Mú ™ ¨@„÷øî„-§¦¦lãG} =Œ°L þǰ…Ø™ê-ĈïÉŧÈ<'é%œ ÒY¢; ‰9|ßÛý«ÃDæe¨àñÂ_|ÑËÀô1<ì8k„%Zë…þü&„vÂ6YÚÙHÙH8½rº†(vcó 3c±˜)a•šSSSJ$/ 75›M w»]ë8ÂEÈÿáÄL±‘PúBIv"ß › aFÊàpò“>(É„¸ måo¸~IæSb“ä÷ÃLlÈéý×Y ª ×€òU¯×mÓÅøjDØ †Ð)×Ñåpb³Fõ!ñ‚î$(áœ5ÿS©TR¡P°xss«…*/µC•…MžÍ“p(סQ±X4BW­V•L&{’4(Ù²´´¤ùùy ß“ ‹Åzº{j‡Ò¯uppPÙlÖ®1K¦HêQ™˜ŸŽÑÑQ% +SÃ,Š"e2#”5Ô>9æ³!$¬¯ær9+éÃ|Eyg,Y(k‚Š‘çÇ<ºé¦›ôw÷wæ å0Dˆ|rrR³³³Êå@D–,ß?ŸÏ÷O§F"u±›PK2Dº(E…݃ç‰uˆ.üŒ$‘#GŽèÈ‘#Z]]U±XÔêꪑ?Tîjµªr¹¬‡~Ø’‚Ûr°dîòŒ’܆úM-B|¬ ÓÊÊŠyQ.›Í¦víÚÕsx ­6Žþ„‡€¯„€ßô¦7immÍêÚªåôO˜',FJhŒ…¿*ˆ$k×E-+¼@”1 ³Z!:´òâTef%äˆé?3”ÁL&£;wšß‡òa(ˆM',o‚/‰ð1Be)$f¼j"Ù²©TÊXBoÙææfOŒ å03‡0Ë$˜àwƒPCÊ„’Gð¾A” C ›º’H$L*•JæÃˆÏ÷¥À7Älá0³’—±"äÇxzç ¡ ¤3ôôñÞƒƒƒæYå~‘ ´¼¼Üs‘d-ËKʤPTK@XeuuÕT—0±¯(ßÅ•q…¼d2Õëu;¨ðñ”A&9”ðïŒ ÷ L´¢ ßb)Bi‡<2æ¡ÂdzÊóÂuðyt8ñLRصu ²ùüóÏ›âa£Ä ¤õLõŸƒ"»pþbI`£Öó~$R ZòÑž;·“'OÚ÷bnªæú¢(²r3$½…!n¾k¥Rщ'tôèQˇ¨òå:Ã8jIÖ5„Úòò²µ‰äšðˆò]™çkkkzöÙg=ÜÇpèxÍ€’ålj’S;Æeþ-Ì’ 7$2(ÙÀØ Ã²lplÎÉdÒ6¼pøzX(9)³è¡Vñþ¨Ž(hx(!qþùçëâ‹/ÖÉ“'-k”Ï „ƒQðüMLL˜ÒIXuccÃT"Êj ²(s(`’ÌÄÍÿŒŒXV îø‘0àãó©ÕjF I˜)‹ZÂc á Ãya}?ÚH¡Ô@l!רÜ?²Cñè­¬¬(‹Y²ï¯ b )…¢ÂEQ¤;wö\'¾=iËßV(L©"K˜6¤o(måBÿ¤$Ìb][[³‚ƧNR§Ó12ÉœC½…ÐÐ+vzzÚÆ„rF†¤í3ÜsžB€››[- ñÀ ZËBˆvxÈàý!M\PgRh™{Ç܇ÛívÍ£I¯Zæ?=˜Q»$¡åý!NÌ7ˆ µ,y v‚#GŽqj·ÛšŸŸ·2‡°5s;ãù#q åŽgâ&ðÌÎÎ*“ÉØ !r|t(»ù|Þº·pࣾàpÎÕëu«6À3¡”µˆCê<áYÆšùÂz100ÐS³2,VM&:pB¥™y&É `ŸÃ  ã5Hh“8Ê¡ P%™*‚w†0 ä¢HÑVÂ’2öH†`“ãû Púa#à4ޝ°Óé˜2¸¶¶¦……óþ<3ÜÄu‘ôÂwE‘ë)XLY(Š”ÏçMƒXNdÃ$¤†ŽŒGÂx,þƒƒƒ–~~*—d*Š!äaÝ=BV5üpÜH;ž-ÈDè ´ŒGÈyX†1’¶û)Ó3;JcGš ’ )Åó…JDÛ,Þ „=T;$¼“„YQT©MIû.êÜ¡ö «P(XÖ6åSP¹î°3¤«¥“˜sؘGFÈ5s…q ‰²$+'B™’V«eYÐ!†Ì†­Üøøfù>”!¹’áB’@ñC<9Ø1?¸'ãããFà Ë$X|)ä.•JvcÍ‘d!×X,f6ðr(ÕÂÁî@sÈW˜œÅµsˆ#ÖÏ'!ޤ.ˆë÷‰Ïa­âYd>soóìAì9…Ê ™±d|!˜”™âpsøða'€} Oqœ5ðþ…Po¨š”YÔ ÔÇb#ƒ<’H `ëT*FŽ ŒløX&!```ÀJ` ÎI2eš|¨”KKK–='©G”f€  6†]@ð#†aPˆK½^7…e jªJX0˜p„ Øèè¨e%Rç°aH6 ŠmóÛí¶…( C…I-étÚˆ"êI`! -ÉÈá¾0ì 9d.´ƒ€äƒ°O-÷‹{ ñ$³·\.Y¥ô >KI¦ö”344dE›kµšºÝ®esÏP¸§Ff(”§4knnN7Ýt“®¹æwÞy¦@CæÃ¤ æ/÷„d%æ"!t>ÌC’V( ’N§{ºs LÛœ"µŒ,nê2§Ã¾ÏüŒ¤-Æ€1d^v»]MOOÛ|BMFé rsˆà}8PAŽ (ccc’e]às9ta!,½ººjµ !øM<¿h¤íÎ@a²÷U’ç˜9†U ∅ç¯#ñ„ý90²Ió™µ8™–Q­yvQø(ÙZ°ÈŒŽŽªV«™:]*•Üèð$ÇÙ# ý†~* ¹RŸP Dͱ^¯[+Iæ5 É`"‘ÐñãÇ%É68ji;I˜¿¶…ô Ò |@ÒX”‰„*•ŠÒé´ý[X»0•J™ºžîÃ’ ¡€Ï,Ìbæ›Í¦òù¼)£|^§³Õ»…’P3]ðUv:ž:t|› .›6cCF)5Ÿ977gÝPL²Ù¬ jµª™™3ëK2U bAv,êh«ÕÒìì¬mö’LA  92®yffÆÈ mÑBb‹Å¬óaR^‹/2|}X&ôµÛm;ÌHêIX`<ÂNÕjÕHdý…^P·ÛÕ©S§$m•¬ÁOFÈÃþ©S§,,ʽÁŸ‡2ÉàYágÒ¶5a||Üzç†!wB‡d¯C”Â÷gp@ ã7,œMwŒ°BRQÜPáWWW­Ã ‡ˆt:m$:ŸÏ›* é…<¡X2„½Í~AÂó—C‘$‹EU«U+$Ï¿5›MI[‰¸wxô8$q›™™1….,EÇU.—­üJ?óC’Êå²0z9¡ ®­­)•JéèÑ£šµDad`³fÒI&Te!í$Aá+Íd2ªV«VÿñèÑ£¯~±wü;^3³€C.ðÑ $qjg—dªê'pBœjQI m¡Z6¼'´‡‰lMêÆœ¨œþñ¬…$Ž ]’‘LˆKè„ì­­­YAlB-¡ç1,.ú¶ i¼á;Ô²…¹¶d2i×QÁH*¨ÝIRˆÅbÚ·oŸZ­–yœ ~ü¸xž ;Ô²>±„8ü RRf‰gessS×^{­ºÝ®Êå²)˜™LÆBä9faíGˆ­PÁ"ôH66D’ï&01Wù=ž#H?ÞÅ0Ù„„I¦6’ܰ¾¾n]P®¹g$Cªõ¬C-¾s*‘HؘòlCj)‡CR…µ!WØQÂÎ>`Æ›¤֨ЛG"WXÆ "G8½\.¿ìyçÀËúÂ=âýèæCm@ž3Ê6Öo6›Õ /¼à!à>†wés|æ3ŸÑÿñkaaA—\r‰î½÷^]sÍ5¯èw):zÁØF@¸—Í”;ì;šï¥m"†d$™7MÚ ÓÒZ‹·\.!ƒ8òz¦5jÇòò²)$lNƒƒƒ¦~žœœT6›Õ¾}ûT.—õä“OZ]6ê”q 's˜M+ŸÏ[wÈ *c,¶Õ¹!TY¤ù|êסöÍÌÌX=B…lNÃÃÃæ#ƒdB®ív»=½vCϯG™„tQ #k~~¾Çð9æskµše¹â7‚°Gé`> PNNNöt9@FmaÌQµ /È' a9ÍfS…BÁÈl˜IN±pDšÍ¦‘V/I¦äL˜ÀÄõ¢åš$Y¶-Šm¸iCÒQIëõºÎ&¬N‚N®† I²Ž—^z©^xá-..Ú³„¢vÂá{ò|@:yo"ÌIIv-Ä••Û¼X$ ›s$7¡¬2Fccc–¤Äó ñ¬V«þæÙ†à…åŸ8<‘Âÿ£^žéñœœœT§Ó1Õ{Éá’{Ì÷ÁOv"+O`"‘èñ3ŸP®ñ¡&“I5 «-ÊZH&2Ï s†1‚\³¶ð܇ý¶%õøuC/³${_”BÈ-v }å+_ñN } ÷ö1¾ô¥/éŽ;îÐ'>ñ }ç;ßÑ5×\£ŸþéŸÖ±cÇ^ÕûŒ÷Ô÷“dá5mI¶p¡"Hê)Ë‚ÎI8ômll(—Ë骫®Ò¯þê¯jçΦá!DÍ kv–&y",-ÂbK&%Åh/ºè"ýÒ¾Œs®>IDAT/ý’fff,dˆ¼^¯÷(%¡ºH¹–0ô<22b~2xQéÈÎEª×ë¦Æ@Nø®‰DÂÂNg6+>‹‚·1Ìî¡©ž Õ€ ˆ ‡ï&.är¹žî+„!sss–¼P*•$ɈeÈN }’’¬þºÕÕUKR ;šä T!”TƉ‰ ÍÏÏ«^¯«ÝnÛk ß¼†¹I&oØ·ÕâÀç2ø,”Gæ}¨"’¾¶¶¦B¡`ê.›6dâAG|o„GG·úàrp lóåñÃAkæ"›ü‚µ7äƒ4 ãí¨S”VÚ*Þ’Ïó†I²Èd2V“ŽÏêt:V3ô%2×ñúAFyæ”@B¯<߬¼'ª7 E<+ÓÓÓ’dϵ$#ZCCC*—ËF’küµ\7% ƒãoF5'ÄO×–z½nó«a_žwK„ÛC¯+ä´Ùlšº\«ÕlŽò¼Åãq5›Mkž9ÂÆCC[­.GÃCÀ}Œ_ù•_Ñþýûõ{¿÷{šššÒ»ßýnýÅ_ü…–––ô®w½ëüý°;!2|xa{€lÊaí;Ê‚ΠË«««Úµk—n¸áÝxãÔƒ>¨J¥b) )ŸAè2,Ù7î°D«ÕÒáÇuêÔ)#mlœY:а)à"<nn¨.ÙlVÒ¶g‹† „šl”pX[[ëIH,H&`S„TÓæ©Ûí*•JYH¬PêƒAn‹Å¢‘5(I9„åPwA¥R1âIBC2™´Íûª–øñ(ÄË&ÖÙãþp-xI"<Î&E‘…766´sçNë…Ì} dfØž©ÄAÆÉ΄¬Qç°^¯[˜"B8‘ùÚl6­n_¨zA¸ ‘s@5"DÈ='Ë“'TÕ°V!óå¸Õj)Š"Ë|†4/--Y-NBžÕjÕæ'¡a|ˆ!iåÀ— áR©dDŒR7ddžÙС—çC’/ßÂOøžk¬ÕjF¾Â>Ë„ô³ÙlO¶4Ï9ªùææ¦­QdˆÖI–C°ëëë=5“ÉdÏáRHˆu||ÜîE¥¹dy¾ éa±zŠ6ƒ]»vÙA‚ÍAƒùÈw"ûšÃ[ás ¿P¢O?ý´‡€ûžÒ§X[[Ó£>ª»îº«çç×_½<øªÞ 5E¥ÝnÛBIh†0 ›¾""B‚ õõuMMMimmM^x¡nºé&Ýpà ¶I\qÅj6›æù¢‰=›Râ¿„“(Ù¶H©TÒ7¾ñ ó.//+ŸÏ[k-6 ìø©gÈfÄÉ\’õð¤,¤$*þ]1ðQA° s¢(¡H`؇d±©„ªµI9räˆPDx}}ÝØP!ã5a=3ÔGþ_Úö²¡‡fv<¡›››¦ôà›b£Æ#E8ŒÃÉÒÖfyòäI+˜Ìbn Œf2 ƒs¯ðî^‹*†Çñ Žiii©'i…qAE”¶Bµ´Î#4‹U€qB¥ ÃŒ¨²$*€CQhÕjÕ,¡HˆœÂÑãããVCÂÏïð]ùþÊd2jµZFnI^a^`Gh6›Êf³¦>òœsxBíŒ1J,Š#V©©);@P3<|¡lŽŽÚøBpî;T# :J5Ê*k£Ñ°gCÏrØs;C~BÍ»víR³Ù4"*õ&¨aàù‰1-Y?H®a­¬V«=Åx¥Ï´ƒ,--Yh><ˆ"fî9úNû•JE*‹=?/‹æ#:a!WIæŸCÉÃV«Õ$ÉÂ[l˜(2llšJœn“¶«|>¯ÙÙYSãhCµ¾¾nİ,}C%Ù‚M¨r‚ú&~@Ri`Oâ¥EZ­–m¨NG/¾ø¢¦¦¦ìÃþ¸,üñxÜÌø(:’z|9QYf' _ØÙ@’mlüÄMšS>^¸0ä I¥,a'Æ RBØŽ WiK±\ dAQ©Ó‡ÓívU¯×­ªRè¹âÞw:ÛÃÎSSS’¶É$*÷ Õ«V«©Õj)ŸÏ[h9T«Õª¶0É€ì\|„¨w(B •Ô—ÜØØÐüü¼©I„@©ÃGÆ{X¯ BËÜGÍ42xå”9”\jJÛÅ€!?aÆ.¤žƒÊ0ór‹"ɸ1° àyäà»óüKÛ„¢T*™ýÄû4›M ó¢Àq a‰!‡KKKÖß™g†’GÌ[H<®§Z­ªÝn+›Íö”œzþùçU(,¹ ˜Ccè“ćI+¿ÉÉI[x> ÐD@X£8<œ9§xÆI ãÙ„Ì‘@¥æeè'W«Õ²ÂרR˜_dÎS€žìdZEv»]oOè_8ìsœY Šð×÷ÃÝwß­?øƒ?xÙÏ:ôùnàë_ÿºî½÷Þègœ ^­gÒáp8ÎÐ2ÑÑpا %Ù™j_©Tz™*~û·[wÞy§ý½Ñhh÷îÝ:vì˜/ g‰V«¥;wêøñãž‘wðq|ýàcùúá\KÔâ;v¼Ñ_ÅñÁ `ŸbxxXûöíÓôs?÷söóè½ï}ï÷ýBIg"•J3‹Úÿv$“IË×>ޝ|,_?œkcé÷þ†À>ÆwÞ©[n¹EW^y¥Þö¶·ésŸûœŽ;¦[o½õþj‡Ãáp8~€pØÇxßûÞ§jµªO}êSZXXÐÞ½{õÕ¯~U»wï~£¿šÃáp8Ž œö9>ò‘è#ùÈkúÝ‘‘}ò“ŸôR¯|,_ø8¾~ð±|ýàcé8á­à‡Ãáp8ú Þ Îáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐñšð™Ï|F{öìÑèè¨öíÛ§ÿøÿx£¿Ò9…»ï¾[o}ë[•H$T(ô³?û³:|øpÏk:Ž>úÑ*ŸÏkbbB7Ýt“Nœ8ÑóšcÇŽég~æg411¡|>¯}ìcÖc¸_q÷Ýwk``@wÜq‡ýÌÇò•ãäÉ“úÀ> \.§ññqýèþ¨}ôQû÷(Šôû¿ÿûÚ±c‡ÆÆÆtíµ×ê©§žêyz½®[n¹E©TJ©TJ·Ür‹õh¯ëw÷wµgÏé¼óÎÓ§>õ)ëo,ùX:ÎqDÇ«Ä}÷ÝÅãñèóŸÿ|tèСèöÛo&&&¢£G¾Ñ_íœÁ 7Ü}á _ˆž|òÉèñÇöïßíÚµ+ZZZ²×Üzë­ÑììltàÀè±Ç‹ÞñŽwD—_~y´¾¾EQ­¯¯G{÷îÞñŽwD=öXtàÀhÇŽÑm·ÝöF]ÖŽGy$zÓ›Þ]vÙeÑí·ßn?÷±|e¨ÕjÑîÝ»£øÃÑÃ?½ôÒKÑ<=ÿüóöš{î¹'J$ÑßÿýßGO<ñDô¾÷½/𙙉Z­–½æÝï~w´wïÞèàÁƒÑÁƒ£½{÷F7ÞxãqIoþðÿ0ÊårÑW¾ò•襗^Šþöoÿ6šœœŒî½÷^{¥ã\†@Ç«ÆýØE·ÞzkÏÏ.¼ðÂè®»îzƒ¾Ñ¹R©IŠ|ðÁ(Š¢¨ÑhDñx<ºï¾ûì5'OžŒ£ù—‰¢(оúÕ¯FƒƒƒÑÉ“'í5ý׌ŒDÍfó‡{çÚívtÁDˆÞþö·ô±|åøøÇ?]}õÕÿ×ßÜÜŒ¦§§£{î¹Ç~¶ºº¥R©èÏþìÏ¢(Š¢C‡E’¢o}ë[öš‡z(’=óÌ3?¸/ŽaÿþýÑ/ÿò/÷üìçþç£|àQùX:Î}xØñª°¶¶¦G}T×_}Ïϯ¿þzšÍ¦$)›ÍJ’}ôQu»Ýžqܱc‡öîÝkãøÐCiïÞ½=ÍÚo¸áu:ž]¿à×ý×µÿ~½ë]ïêù¹å+Ç—¿üe]yå•ú…_ø ½å-oÑç?ÿyû÷—^zI‹‹‹=c922¢·¿ýí=c™J¥ôã?þãöš«®ºJ©Tª¯Ö€«¯¾Z_ÿú×õì³ÏJ’þû¿ÿ[ßüæ7õž÷¼G’¥ã܇wq¼*T*mll¨X,öü¼X,jqqñ úVç6¢(ÒwÞ©«¯¾Z{÷î•$-..jxxX™L¦çµá8...¾lœ3™Œ†‡‡ûn¬ï»ï>=öØcúö·¿ý²ó±|åxñÅõÙÏ~VwÞy§~çw~G<òˆ>ö±iddDüàm,¾ßó}ôèQI[cY(^öÞ…B¡¯Æòãÿ¸šÍ¦.¼ðB iccCŸþô§õþ÷¿_’|,ç<œ:^zþEÑË~æØÂm·Ý¦ï~÷»úæ7¿ù?¾öÌqü~cÚoc}üøqÝ~ûíúÚ×¾¦ÑÑÑWü{>–/Çææ¦®¼òJýÑý‘$é-oy‹žzê)}ö³ŸÕ?øA{Ýÿô|ûXJ_úÒ—ôÅ/~QõW¥K.¹D?þ¸î¸ãíØ±CúЇìu>–Žsv¼*äóy ½ìtZ*•^vÒuHýèGõå/Yÿþïÿ®¹¹9ûùôô´ÖÖÖT¯×{^ŽãôôôËÆ¹^¯«ÛíöÕX?úè£*•JÚ·oŸb±˜b±˜|ðAýÉŸü‰b±˜ŠÅ¢å+ÄÌÌŒ.¾øâžŸ]tÑE:v오­q’ôÿ|¾§§§uêÔ©—½w¹\üÍßüMÝu×]úÅ_üE]z饺å–[ô¿ñºûî»%ùX:Î}8t¼* kß¾}:pà@ÏÏ8 Ÿø‰Ÿxƒ¾Õ¹‡(ŠtÛm·éþûï׿ýÛ¿iÏž==ÿ¾oß>Åãñžq\XXГO>iãø¶·½MO>ù¤ì5_ûÚ×422¢}ûöýp.äÀu×]§'žxB?þ¸ý¹òÊ+uóÍ7ÛÿûX¾2üäOþäËÊ=ûì³Ú½{·$iÏž=šžžî˵µ5=øàƒ=cÙl6õÈ#Øk~øa5›Í¾ZVVV48Ø»… YKÇ97(ùÄñ¿”ùó?ÿóèСCÑwÜMLLDGŽy£¿Ú9ƒ_ûµ_‹R©Tôo|#ZXX°?+++öš[o½5š››‹xàè±Ç‹ÞùÎw~ßÒ%×]w]ôØcE<ð@477×w¥K¾Â,à(ò±|¥xä‘G¢X,}úÓŸŽž{î¹è/ÿò/£ñññè‹_ü¢½æž{î‰R©Ttÿý÷GO<ñDôþ÷¿ÿû–.¹ì²Ë¢‡z(z衇¢K/½´ïJ—|èCŠfgg­ Ìý÷ßåóùè·~ë·ì5>–ŽsN¯ ú§íÞ½;Ž®¸â +oâØ‚¤ïûç _ø‚½æôéÓÑm·Ýe³Ùhll,ºñÆ£cÇŽõ¼ÏÑ£G£ýû÷GcccQ6›n»í¶huuõ‡|5çÎ$€>–¯ÿøÿíÝ»7‰.¼ðÂèsŸû\Ï¿onnFŸüä'£éééhdd$ú©Ÿú©è‰'žèyMµZn¾ùæ(‘HD‰D"ºù曣z½þüŒ7­V+ºýöÛ£]»vE£££Ñyç}⟈:޽ÆÇÒq.c Š¢èT ‡Ãáp8?\¸Ðáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏàÐáp8‡£ÏðÝ66ŽûܼIEND®B`‚regions-0.4/docs/_templates/0000755000076600000240000000000013501657425016161 5ustar deilstaff00000000000000regions-0.4/docs/_templates/autosummary/0000755000076600000240000000000013501657425020547 5ustar deilstaff00000000000000regions-0.4/docs/_templates/autosummary/base.rst0000644000076600000240000000037213336761120022207 0ustar deilstaff00000000000000{% extends "autosummary_core/base.rst" %} {# The template this is inherited from is in astropy/sphinx/ext/templates/autosummary_core. If you want to modify this template, it is strongly recommended that you still inherit from the astropy template. #}regions-0.4/docs/_templates/autosummary/class.rst0000644000076600000240000000037313336761120022403 0ustar deilstaff00000000000000{% extends "autosummary_core/class.rst" %} {# The template this is inherited from is in astropy/sphinx/ext/templates/autosummary_core. If you want to modify this template, it is strongly recommended that you still inherit from the astropy template. #}regions-0.4/docs/_templates/autosummary/module.rst0000644000076600000240000000037413336761120022564 0ustar deilstaff00000000000000{% extends "autosummary_core/module.rst" %} {# The template this is inherited from is in astropy/sphinx/ext/templates/autosummary_core. If you want to modify this template, it is strongly recommended that you still inherit from the astropy template. #}regions-0.4/docs/api.rst0000644000076600000240000000012113336761120015313 0ustar deilstaff00000000000000Reference/API ============= .. automodapi:: regions :no-inheritance-diagram: regions-0.4/docs/changelog.rst0000644000076600000240000000013313347162104016473 0ustar deilstaff00000000000000.. _changelog: ************** Full Changelog ************** .. include:: ../CHANGES.rst regions-0.4/docs/compound.rst0000644000076600000240000000350013501414013016360 0ustar deilstaff00000000000000 .. _gs-compound: Combining regions ================= There's a few ways to combine any two `~regions.Region` objects into a compound region, i.e. a `~regions.CompoundPixelRegion` or `~regions.CompoundSkyRegion` object. * The ``&`` operator calls the ``__and__`` method which calls the :meth:`~regions.Region.intersection` method to create an intersection compound region. * The ``|`` operator calls the ``__or__`` method which calls the :meth:`~regions.Region.union` method to create a union compound region. * The ``^`` operator calls the ``__xor__`` method which calls the :meth:`~regions.Region.symmetric_difference` method to create a symmetric difference compound region. .. code-block:: python >>> from astropy.coordinates import Angle, SkyCoord >>> from regions import CircleSkyRegion >>> circle1 = CircleSkyRegion( ... center=SkyCoord(1,2, unit='deg', frame='galactic'), ... radius=Angle('5 deg') ... ) >>> circle2 = CircleSkyRegion( ... center=SkyCoord(-4,3, unit='deg', frame='galactic'), ... radius=Angle('3 deg'), ... ) >>> print(circle1 & circle2) Region: CompoundSkyRegion region1: Region: CircleSkyRegion center: radius: 5.0 deg region2: Region: CircleSkyRegion center: radius: 3.0 deg operator: >>> print(circle1 ^ circle2) Region: CompoundSkyRegion region1: Region: CircleSkyRegion center: radius: 5.0 deg region2: Region: CircleSkyRegion center: radius: 3.0 deg operator: .. plot:: plot_compound.py :include-source: false regions-0.4/docs/conf.py0000644000076600000240000001540413347162104015320 0ustar deilstaff00000000000000# -*- coding: utf-8 -*- # Licensed under a 3-clause BSD style license - see LICENSE.rst # # Astropy documentation build configuration file. # # This file is execfile()d with the current directory set to its containing dir. # # Note that not all possible configuration values are present in this file. # # All configuration values have a default. Some values are defined in # the global Astropy configuration which is loaded here before anything else. # See astropy.sphinx.conf for which values are set there. # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # sys.path.insert(0, os.path.abspath('..')) # IMPORTANT: the above commented section was generated by sphinx-quickstart, but # is *NOT* appropriate for astropy or Astropy affiliated packages. It is left # commented out with this explanation to make it clear why this should not be # done. If the sys.path entry above is added, when the astropy.sphinx.conf # import occurs, it will import the *source* version of astropy instead of the # version installed (if invoked as "make html" or directly with sphinx), or the # version in the build directory (if "python setup.py build_sphinx" is used). # Thus, any C-extensions that are needed to build the documentation will *not* # be accessible, and the documentation will not build correctly. import datetime import os import sys try: import astropy_helpers except ImportError: # Building from inside the docs/ directory? if os.path.basename(os.getcwd()) == 'docs': a_h_path = os.path.abspath(os.path.join('..', 'astropy_helpers')) if os.path.isdir(a_h_path): sys.path.insert(1, a_h_path) # Load all of the global Astropy configuration from astropy_helpers.sphinx.conf import * # Get configuration information from setup.cfg try: from ConfigParser import ConfigParser except ImportError: from configparser import ConfigParser conf = ConfigParser() conf.read([os.path.join(os.path.dirname(__file__), '..', 'setup.cfg')]) setup_cfg = dict(conf.items('metadata')) # -- General configuration ---------------------------------------------------- del intersphinx_mapping['scipy'] del intersphinx_mapping['h5py'] intersphinx_mapping['photutils'] = ('http://photutils.readthedocs.io/en/latest/', None) # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.2' # To perform a Sphinx version check that needs to be more specific than # major.minor, call `check_sphinx_version("x.y.z")` here. # check_sphinx_version("1.2.1") # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns.append('_templates') # This is added to the end of RST files - a good place to put substitutions to # be used globally. rst_epilog += """ """ # -- Project information ------------------------------------------------------ # This does not *have* to match the package name, but typically does project = setup_cfg['package_name'] author = setup_cfg['author'] copyright = '{0}, {1}'.format( datetime.datetime.now().year, setup_cfg['author']) # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. __import__(setup_cfg['package_name']) package = sys.modules[setup_cfg['package_name']] # The short X.Y version. version = package.__version__.split('-', 1)[0] # The full version, including alpha/beta/rc tags. release = package.__version__ # -- Options for HTML output --------------------------------------------------- # A NOTE ON HTML THEMES # The global astropy configuration uses a custom theme, 'bootstrap-astropy', # which is installed along with astropy. A different theme can be used or # the options for this theme can be modified by overriding some of the # variables set in the global configuration. The variables set in the # global configuration are listed below, commented out. # Add any paths that contain custom themes here, relative to this directory. # To use a different custom theme, add the directory containing the theme. # html_theme_path = [] # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. To override the custom theme, set this to the # name of a builtin theme or the name of a custom theme in html_theme_path. #html_theme = None # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = '' # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '' # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". html_title = '{0} v{1}'.format(project, release) # Output file base name for HTML help builder. htmlhelp_basename = project + 'doc' # -- Options for LaTeX output -------------------------------------------------- # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [('index', project + '.tex', project + u' Documentation', author, 'manual')] # -- Options for manual page output -------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [('index', project.lower(), project + u' Documentation', [author], 1)] ## -- Options for the edit_on_github extension ---------------------------------------- if eval(setup_cfg.get('edit_on_github')): extensions += ['astropy_helpers.sphinx.ext.edit_on_github'] versionmod = __import__(setup_cfg['package_name'] + '.version') edit_on_github_project = setup_cfg['github_project'] if versionmod.version.release: edit_on_github_branch = "v" + versionmod.version.version else: edit_on_github_branch = "master" edit_on_github_source_root = "" edit_on_github_doc_root = "docs" github_issues_url = 'https://github.com/astropy/regions/issues/' plot_rcparams = {'savefig.bbox': 'tight', 'savefig.facecolor':'none', 'axes.formatter.useoffset': False, 'xtick.labelsize': 9, 'ytick.labelsize': 9, 'axes.labelsize': 11, 'figure.titlesize': 11, 'figure.subplot.wspace': 0.23, 'figure.subplot.hspace': 0.23} plot_apply_rcparams = True regions-0.4/docs/contains.rst0000644000076600000240000000434713501414013016364 0ustar deilstaff00000000000000.. testsetup: >>> from regions import make_example_dataset >>> dataset = make_example_dataset(data='simulated') >>> wcs = dataset.wcs .. _gs-contain: Checking for points inside regions ================================== Let's continue with sky and pixel regions defined in the :ref:`gs` section: .. code-block:: python >>> from astropy.coordinates import Angle, SkyCoord >>> from regions import CircleSkyRegion, PixCoord, CirclePixelRegion >>> sky_center = SkyCoord(42, 43, unit='deg') >>> sky_radius = Angle(25, 'deg') >>> sky_region = CircleSkyRegion(sky_center, sky_radius) >>> pixel_center = PixCoord(x=42, y=43) >>> pixel_radius = 42 >>> pixel_region = CirclePixelRegion(pixel_center, pixel_radius) >>> print(sky_region) Region: CircleSkyRegion center: radius: 25.0 deg >>> print(pixel_region) Region: CirclePixelRegion center: PixCoord(x=42, y=43) radius: 42 To test if a given point is inside or outside the regions, the Python ``in`` operator can be called, which calls the special ``__contains__`` method defined on the region classes: .. code-block:: python >>> from regions import PixCoord >>> PixCoord(55, 40) in pixel_region True >>> PixCoord(55, 200) in pixel_region False The ``in`` operator only works for scalar coordinates, because Python requires the return value to be a scalar bool, and only works for pixel regions. If you try to use ``in`` for non-scalar coordinates, you'll get a ``ValueError``: .. code-block:: python >>> pixcoord = PixCoord([50, 50], [10, 60]) >>> pixcoord in pixel_region Traceback (most recent call last): ... ValueError: coord must be scalar. coord=PixCoord(x=[50 50], y=[10 60]) If you have arrays of coordinates, use the `regions.SkyRegion.contains` or `regions.PixelRegion.contains` methods: .. code-block:: python >>> pixcoords = PixCoord.from_sky(sky_center, wcs) >>> pixel_region.contains(pixcoords) True Note that `regions.SkyRegion.contains` requires a WCS to be passed: .. code-block:: python >>> skycoord = SkyCoord([50, 50], [10, 60], unit='deg') >>> sky_region.contains(skycoord, wcs) array([False, True]) regions-0.4/docs/crtf.rst0000644000076600000240000000441013501414013015473 0ustar deilstaff00000000000000.. _gs-crtf: Reading/writing to CRTF region files ==================================== CASA Region Text Format (CRTF) : The CASA region file format provides a flexible, easily edited set of region definitions which are accepted across CASA tasks. The regions package provides the functionality to serialise and de-serialise Python lists of `~regions.Region` objects to CRTF region strings. De-serialisation is done using the `~regions.CRTFParser`. It converts the CRTF string to `~regions.ShapeList` object, which is a list of `~regions.Shape` each representing one CRTF region. The `~regions.Shape` objects can be converted to `~regions.Region` objects. To learn more about the format specifications, please go to `the official page `_. .. code-block:: python >>> from regions import CRTFParser >>> reg_string = 'circle[[42deg, 43deg], 3deg], coord=J2000, color=green ' >>> parser = CRTFParser(reg_string) >>> print(parser.shapes[0]) Shape Type : reg Coord sys : fk5 Region type : circle Meta: {'color': 'green', 'include': True, 'type': 'reg'} Composite: False Include: True >>> regions = parser.shapes.to_regions() >>> print(regions[0]) Region: CircleSkyRegion center: radius: 3.0 deg >>> print(regions[0].meta) {'include': True, 'type': 'reg'} >>> print(regions[0].visual) {'color': 'green'} Serialisation is done using the `~regions.crtf_objects_to_string` function .. code-block:: python >>> from regions import crtf_objects_to_string >>> crtf_objects_to_string(regions, coordsys='galactic') '#CRTF\ncircle[[144.559169deg, -14.923593deg], 3.000000deg], coord=GALACTIC, color=green\n' There's also `~regions.write_crtf` and `~regions.read_crtf` which write to and read from a file in addition to doing the region serialisation and parsing. .. code-block:: python >>> from regions import read_crtf, write_crtf >>> filename = 'region.crtf' >>> write_crtf(regions, filename) >>> regions = read_crtf(filename) >>> regions [, radius=3.0 deg)>] regions-0.4/docs/development.rst0000644000076600000240000000112213336761120017066 0ustar deilstaff00000000000000.. include:: references.txt Development =========== If you have a feature request or would like to contribute to ``regions``, please go here: https://github.com/astropy/regions/ Notes ----- Minutes for the discussions on regions: * `Python in astronomy 2015 `__ * `Python in astronomy 2016 `__ Dependencies ------------ Should we use these packages or start building functionality from scratch? * spherical_geometry https://github.com/spacetelescope/sphere * Shapely https://pypi.python.org/pypi/Shapely regions-0.4/docs/ds9.rst0000644000076600000240000000402613501414013015237 0ustar deilstaff00000000000000.. _gs-ds9: Reading/writing to DS9 region files =================================== The regions package provides the functionality to serialise and de-serialise Python lists of `~regions.Region` objects to DS9 region strings. De-serialisation is done using the `~regions.DS9Parser`. It converts the DS9 string to `~regions.ShapeList` object, which is a list of `~regions.Shape` each representing one DS9 region. The `~regions.Shape` objects can be converted to `~regions.Region` objects. .. code-block:: python >>> from regions import DS9Parser >>> reg_string = 'galactic\ncircle(42,43,3) # color=green' >>> parser = DS9Parser(reg_string) >>> print(parser.shapes[0]) Shape Type : reg Coord sys : galactic Region type : circle Meta: {'color': 'green', 'include': True} Composite: False Include: True >>> regions = parser.shapes.to_regions() >>> print(regions[0]) Region: CircleSkyRegion center: radius: 3.0 deg Serialisation is done using the `~regions.ds9_objects_to_string` function >>> from regions import ds9_objects_to_string >>> ds9_objects_to_string(regions, coordsys='galactic') '# Region file format: DS9 astropy/regions\ngalactic\ncircle(42.000000,43.000000,3.000000) # color=green\n' There's also `~regions.write_ds9` and `~regions.read_ds9` which write to and read from a file in addition to doing the region serialisation and parsing. .. code-block:: python >>> from regions import read_ds9, write_ds9 >>> filename = 'ds9.reg' >>> write_ds9(regions, filename) >>> regions = read_ds9(filename) >>> regions [, radius=3.0 deg)>] The ``visual`` metadata includes items used for display, e.g.: .. code-block:: python >>> print(regions[0].visual) {'color': 'green'} Some of these keyword may eventually be used by the plotting utilities and standardized, but they are not as of v0.3. regions-0.4/docs/fits_region.rst0000644000076600000240000001101113501414013017040 0ustar deilstaff00000000000000.. _gs-fits: Reading/writing to FITS region files ==================================== The regions package provides the functionality to serialise and de-serialise Python lists of `~regions.Region` objects to FITS region file. A `FITS Region Binary Table `_ defines a spatial region of a two-dimensional image in pixels. The name of the header must be ``REGION`` for the `~regions.read_fits_region` to parse the table. The file is read using the `~astropy.table.Table.read` method which converts it into a `~astropy.table.Table` object. `~regions.FITSRegionParser` parses this table. It converts the FITS region table to a `~regions.ShapeList` object, which is a list of `~regions.Shape`, each representing one FITS region in pixels. It should be noted that the regions are actually described in sky coordinates. It is converted explicitly to sky regions in the `~regions.read_fits_region` using the `to_sky` method. The `~astropy.wcs.WCS` object is created with the help of FITS header of the file. The `~regions.Shape` objects can be converted to `~regions.Region` objects. Some of the regions such as ``rectangle``, ``rotrectangle``, ``pie``, ``sector`` are not supported by this package. .. code-block:: python >>> from regions import FITSRegionParser >>> from astropy.table import Table >>> from astropy.utils.data import get_pkg_data_filename >>> filename = get_pkg_data_filename('data/fits_region.fits', ... package='regions.io.fits.tests') >>> table = Table.read(filename) >>> print(table) X [4] Y [4] SHAPE R [4] ROTANG COMPONENT pix pix pix deg ---------------- ---------------- ------- ---------------- --------- --------- 2896.5 .. 0.0 5056.5 .. 0.0 circle 381.9716 .. 0.0 0.0 1 5282.0541 .. 0.0 4854.5699 .. 0.0 ROTBOX 1303.4597 .. 0.0 28.395178 2 2944.5 .. 0.0 3472.5 .. 0.0 ellipse 288.0 .. 0.0 337.4048 3 341.0 .. 0.0 345.0 .. 0.0 ROTBOX 56.0 .. 0.0 65.0 4 341.0 .. 0.0 345.0 .. 0.0 ANNULUS 56.0 .. 0.0 0.0 5 341.0 .. 0.0 345.0 .. 0.0 point 0.0 .. 0.0 0.0 6 341.0 .. 0.0 345.0 .. 0.0 point 0.0 .. 0.0 0.0 7 1.0 .. 4.0 5.0 .. 8.0 polygon 0.0 .. 0.0 0.0 8 10.0 .. 0.0 5.5 .. 0.0 BOX 10.0 .. 0.0 0.0 9 >>> parser = FITSRegionParser(table) >>> print(parser.shapes[0]) Shape Type : reg Coord sys : physical Region type : circle Meta: {'tag': '1'} Composite: False Include: False >>> regions = parser.shapes.to_regions() # pixel regions >>> print(regions[0]) Region: CirclePixelRegion center: PixCoord(x=2896.5, y=5056.5) radius: 381.9716 Serialisation is done using the `~regions.fits_region_objects_to_table` function .. code-block:: python >>> from regions import fits_region_objects_to_table >>> table_ouput = fits_region_objects_to_table(regions) >>> print(table_ouput) X [4] Y [4] SHAPE R [4] ROTANG COMPONENT pix pix pix deg ---------------- ---------------- ------- ---------------- --------- --------- 2896.5 .. 0.0 5056.5 .. 0.0 circle 381.9716 .. 0.0 0.0 1 5282.0541 .. 0.0 4854.5699 .. 0.0 ROTBOX 1303.4597 .. 0.0 28.395178 2 2944.5 .. 0.0 3472.5 .. 0.0 ellipse 288.0 .. 0.0 337.4048 3 341.0 .. 0.0 345.0 .. 0.0 ROTBOX 56.0 .. 0.0 65.0 4 341.0 .. 0.0 345.0 .. 0.0 ANNULUS 56.0 .. 0.0 0.0 5 341.0 .. 0.0 345.0 .. 0.0 point 0.0 .. 0.0 0.0 6 341.0 .. 0.0 345.0 .. 0.0 point 0.0 .. 0.0 0.0 7 1.0 .. 4.0 5.0 .. 8.0 polygon 0.0 .. 0.0 0.0 8 10.0 .. 0.0 5.5 .. 0.0 ROTBOX 10.0 .. 0.0 0.0 9 The `~regions.write_fits_region` and `~regions.read_fits_region` functions write as well as read from a file in addition to doing the region serialisation and parsing. .. code-block:: python >>> from regions import CirclePixelRegion, PixCoord, write_fits_region >>> reg_pixel = CirclePixelRegion(PixCoord(1, 2), 5) >>> write_fits_region('regions_output.fits', regions=[reg_pixel]) regions-0.4/docs/getting_started.rst0000644000076600000240000001535713501414013017740 0ustar deilstaff00000000000000.. include:: references.txt .. _gs: Getting started =============== .. _gs-intro: Introduction ------------ The `regions` package provides (or plans to provide) classes to represent: * Regions defined using pixel coordinates (`~regions.CirclePixelRegion`) * Regions defined using celestial coordinates, but still in an Euclidean geometry (`~regions.CircleSkyRegion`) * Regions defined on the celestial sphere (no examples yet) To transform between sky and pixel regions, a world coordinate system (represented by a `~astropy.wcs.WCS` object) is needed. Some functions for region-based calculations (e.g. filtering a table of sky or pixel positions) as well as functions for region serialisation (e.g. to and from ds9/crtf region string format) are available. .. _gs-ds: Dataset ------- Throughout the documentation, we will be working with the same example dataset and assume that you have run `~regions.make_example_dataset` to create example ``dataset`` and ``wcs`` objects like this: .. code-block:: python >>> from regions import make_example_dataset >>> dataset = make_example_dataset(data='simulated') >>> wcs = dataset.wcs For image examples, we will use the ``wcs`` and ``image`` attributes. For example positions, we will use the ``source_table`` and ``event_table`` attributes. In your own analyses, you will usually load image data and WCS objects from file or compute them with a Python script. We don't do this here, because we wanted to make this tutorial independent of any example data files, to help you get started quickly. Also, this example image was created to illustrate some of the key issues when working with regions. It represents an all-sky image in Aitoff (``AIT``) projection, which means that there are pixels at the edge of the image that don't correspond to positions on the sky. And the pixels are huge, roughly 10 deg time 10 deg, which means that there are well-visible differences between sky and pixel regions, caused by the WCS projection. Before we start diving into coding with regions, here's an image that illustrates our example counts image, with source positions and a few regions overplotted: .. plot:: plot_example.py :include-source: false .. _gs-coord: Coordinates ----------- This regions package uses :class:`~astropy.coordinates.SkyCoord` objects to represent sky coordinates. .. code-block:: python >>> from astropy.coordinates import SkyCoord >>> skycoord = SkyCoord(42, 43, unit='deg', frame='galactic') >>> skycoord To represent pixel coordinates, :class:`~regions.PixCoord` objects are used. .. code-block:: python >>> from regions import PixCoord >>> pixcoord = PixCoord(x=42, y=43) >>> pixcoord PixCoord(x=42, y=43) >>> pixcoord.x 42 >>> pixcoord.y 43 `~astropy.coordinates.SkyCoord` is a very powerful and complex class (different representations, a coordinate transformation tree) that is documented extensively in the `astropy.coordinates` docs. In contrast, `~regions.PixCoord` is a small and simple helper class. The pixel coordinate is always represented as cartesian coordinate data members ``x`` and ``y``. A pixel coordinate doesn't have a frame and is not connected to the `astropy.coordinates` transformation tree. For a given image, represented by a `~astropy.wcs.WCS` object, it's easy to transform back and forth between sky and pixel coordinates: .. code-block:: python >>> skycoord = SkyCoord(42, 43, unit='deg', frame='galactic') >>> pixcoord = PixCoord.from_sky(skycoord=skycoord, wcs=wcs) >>> pixcoord # doctest: +FLOAT_CMP PixCoord(x=146.2575703393558, y=131.5998051082584) >>> pixcoord.to_sky(wcs=wcs) This is an object-oriented thin wrapper around the functionality provided by `~astropy.wcs.WCS` and `astropy.wcs.utils`. It is possible to create `~astropy.coordinates.SkyCoord` and `~regions.PixCoord` objects that represent arrays of pixel coordinates, and operations like transforming between sky- and pixel or region containment checks work as expected (i.e. return arrays of the same shape as the inputs, and perform operations on array entries independently. .. code-block:: python # One-dimensional array of pixel coordinates >>> pixcoord = PixCoord(x=[0, 1], y=[2, 3]) >>> pixcoord PixCoord(x=[0 1], y=[2 3]) # Two-dimensional array pixel coordinates: >>> pixcoord = PixCoord( ... x=[[1, 2, 3], [4, 5, 6]], ... y=[[11, 12, 13], [14, 15, 16]] ... ) >>> print(pixcoord) PixCoord(x=[[1 2 3] [4 5 6]], y=[[11 12 13] [14 15 16]]) To represent angles both on the sky and in an image, `~astropy.coordinates.Angle` objects or `~astropy.units.Quantity` objects with angular units can be used. .. _gs-sky: Sky regions ----------- Sky regions are regions that are defined using celestial coordinates. Note that these are **not** defined as regions on the celestial sphere, but rather are meant to represent shapes on an image, but simply defined using celestial coordinates as opposed to pixel coordinates. This is how to create a sky region: .. code-block:: python >>> from astropy.coordinates import Angle, SkyCoord >>> from regions import CircleSkyRegion >>> center = SkyCoord(42, 43, unit='deg') >>> radius = Angle(3, 'deg') >>> region = CircleSkyRegion(center, radius) You can print the regions to get some info about its properties: .. code-block:: python >>> print(region) Region: CircleSkyRegion center: radius: 3.0 deg To see a list of all available sky regions, you can go to the API docs or in IPython print the list using: .. code-block:: none In [1]: import regions In [2]: regions.*SkyRegion? .. _gs-pix: Pixel regions ------------- In some cases you might instead want to directly represent a region in pixel coordinates. For those, there's a `~regions.PixCoord` class to represent a point, and a set of "pixel region" classes. One example is `~regions.CirclePixelRegion`: .. code-block:: python >>> from astropy.coordinates import Angle, SkyCoord >>> from regions import PixCoord, CirclePixelRegion >>> center = PixCoord(x=42, y=43) >>> radius = 4.2 >>> region = CirclePixelRegion(center, radius) You can print the regions to get some info about its properties: .. code-block:: python >>> print(region) Region: CirclePixelRegion center: PixCoord(x=42, y=43) radius: 4.2 To see a list of all available sky regions, you can go to the API docs or in IPython print the list using: .. code-block:: none In [1]: import regions In [2]: regions.*PixelRegion? To learn more about :class:`~regions.Region` and it's capabilities in :ref:`sh` regions-0.4/docs/index.rst0000644000076600000240000000763513501414013015660 0ustar deilstaff00000000000000.. include:: references.txt .. warning:: This ``regions`` package is in a very early stage of development. It is neither feature complete nor API stable! That said, please have a look and try to use it for your applications. Feedback and contributions are welcome! ############################# Astropy Regions Documentation ############################# This is an in-development `affiliated package`_ of `Astropy`_ for region handling. To get an overview of available features, see :ref:`gs`. The goal is to merge the functionality from `pyregion`_ and `photutils`_ apertures and then after some time propose this package for inclusion in the Astropy core. * Code : `Github repository`_ * Docs : `Region documentation`_ * Contributors : https://github.com/astropy/regions/graphs/contributors * Releases: https://pypi.python.org/pypi/regions User Documentation ================== .. toctree:: :maxdepth: 1 installation getting_started shapes contains compound masks plotting ds9 crtf fits_region shapely changelog +----------------------------------------+----------------------------------------+ | ds9 | regions + matplotlib | +========================================+========================================+ | .. image:: _static/region_ds9.png | .. plot:: plot_reg.py | | :width: 300px | :width: 300px | | :target: _static/region_ds9.png | | +----------------------------------------+----------------------------------------+ Advanced ======== .. toctree:: :maxdepth: 1 api development Reporting Issues ================ If you have found a bug in Regions please report it by creating a new issue on the `Regions GitHub issue tracker `_. Please include an example that demonstrates the issue that will allow the developers to reproduce and fix the problem. You may also be asked to provide information about your operating system and a full Python stack trace. The developers will walk you through obtaining a stack trace if it is necessary. Astropy Regions uses a package of utilities called `astropy-helpers `_ during building and installation. If you have any build or installation issue mentioning the ``astropy_helpers`` or ``ah_bootstrap`` modules please send a report to the `astropy-helpers issue tracker `_. If you are unsure, then it's fine to report to the main Regions issue tracker. Contributing ============ Like the `Astropy`_ project, Regions is made both by and for its users. We accept contributions at all levels, spanning the gamut from fixing a typo in the documentation to developing a major new feature. We welcome contributors who will abide by the `Python Software Foundation Code of Conduct `_. If you have a feature request or would like to contribute to ``regions``, please go here: https://github.com/astropy/regions/ Regions follows the same workflow and coding guidelines as `Astropy`_. The following pages will help you get started with contributing fixes, code, or documentation (no git or GitHub experience necessary): * `How to make a code contribution `_ * `Coding Guidelines `_ * `Try the development version `_ * `Developer Documentation `_ Get Help ======== Besides github, you can `get help`_ from the community in a number of ways. There is also a slack channel for regions hosted under the main astropy slack. regions-0.4/docs/installation.rst0000644000076600000240000000365613467310773017274 0ustar deilstaff00000000000000.. include:: references.txt .. _install: ************ Installation ************ The regions package requires the following packages: * Python 2.7 or 3.4 and above * `Numpy `_ 1.9 or later * `Astropy `__ 1.3 or later * `six `__ In addition, the following packages are needed for optional functionality: * `Matplotlib `__ 1.5 or later Stable version ============== Installing the latest stable version is possible either using pip or conda. Using pip --------- To install regions with `pip `_ from `PyPI `_, run:: pip install regions --no-deps .. note:: The ``--no-deps`` flag is optional, but highly recommended if you already have Numpy installed, since otherwise pip will sometimes try to "help" you by upgrading your Numpy installation, which may not always be desired. Using conda ----------- To install regions with `Anaconda `_ from the `astropy channel on anaconda.org `__ simply run:: conda install -c astropy regions Testing installation -------------------- To check if there are any issues with your installation, you can run the tests: .. code-block:: bash python -c 'import regions; regions.test()' Development version =================== Install the latest development version from https://github.com/astropy/regions : .. code-block:: bash git clone https://github.com/astropy/regions cd regions python setup.py install To run the tests, you will need to make sure the `pytest-arraydiff `_ package is installed (version v0.3 or newer). Then, run the tests with: .. code-block:: bash python setup.py test To build the documentation, do: .. code-block:: bash python setup.py build_docs regions-0.4/docs/make.bat0000644000076600000240000001064113336761120015425 0ustar deilstaff00000000000000@ECHO OFF REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set BUILDDIR=_build set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% . if NOT "%PAPER%" == "" ( set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% ) if "%1" == "" goto help if "%1" == "help" ( :help echo.Please use `make ^` where ^ is one of echo. html to make standalone HTML files echo. dirhtml to make HTML files named index.html in directories echo. singlehtml to make a single large HTML file echo. pickle to make pickle files echo. json to make JSON files echo. htmlhelp to make HTML files and a HTML help project echo. qthelp to make HTML files and a qthelp project echo. devhelp to make HTML files and a Devhelp project echo. epub to make an epub echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter echo. text to make text files echo. man to make manual pages echo. changes to make an overview over all changed/added/deprecated items echo. linkcheck to check all external links for integrity echo. doctest to run all doctests embedded in the documentation if enabled goto end ) if "%1" == "clean" ( for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i del /q /s %BUILDDIR%\* goto end ) if "%1" == "html" ( %SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/html. goto end ) if "%1" == "dirhtml" ( %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml. goto end ) if "%1" == "singlehtml" ( %SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml. goto end ) if "%1" == "pickle" ( %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the pickle files. goto end ) if "%1" == "json" ( %SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the JSON files. goto end ) if "%1" == "htmlhelp" ( %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run HTML Help Workshop with the ^ .hhp project file in %BUILDDIR%/htmlhelp. goto end ) if "%1" == "qthelp" ( %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run "qcollectiongenerator" with the ^ .qhcp project file in %BUILDDIR%/qthelp, like this: echo.^> qcollectiongenerator %BUILDDIR%\qthelp\Astropy.qhcp echo.To view the help file: echo.^> assistant -collectionFile %BUILDDIR%\qthelp\Astropy.ghc goto end ) if "%1" == "devhelp" ( %SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp if errorlevel 1 exit /b 1 echo. echo.Build finished. goto end ) if "%1" == "epub" ( %SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub if errorlevel 1 exit /b 1 echo. echo.Build finished. The epub file is in %BUILDDIR%/epub. goto end ) if "%1" == "latex" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex if errorlevel 1 exit /b 1 echo. echo.Build finished; the LaTeX files are in %BUILDDIR%/latex. goto end ) if "%1" == "text" ( %SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text if errorlevel 1 exit /b 1 echo. echo.Build finished. The text files are in %BUILDDIR%/text. goto end ) if "%1" == "man" ( %SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man if errorlevel 1 exit /b 1 echo. echo.Build finished. The manual pages are in %BUILDDIR%/man. goto end ) if "%1" == "changes" ( %SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes if errorlevel 1 exit /b 1 echo. echo.The overview file is in %BUILDDIR%/changes. goto end ) if "%1" == "linkcheck" ( %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck if errorlevel 1 exit /b 1 echo. echo.Link check complete; look for any errors in the above output ^ or in %BUILDDIR%/linkcheck/output.txt. goto end ) if "%1" == "doctest" ( %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest if errorlevel 1 exit /b 1 echo. echo.Testing of doctests in the sources finished, look at the ^ results in %BUILDDIR%/doctest/output.txt. goto end ) :end regions-0.4/docs/masks.rst0000644000076600000240000002103613501414013015656 0ustar deilstaff00000000000000 .. _gs-masks: Computing overlap masks ======================= Defining a region mask within its bounding box ---------------------------------------------- For aperture photometry, a common operation is to compute, for a given image and region, a mask or array of pixel indices defining which pixels (in the whole image or a minimal rectangular bounding box) are inside and outside the region. All :class:`~regions.PixelRegion` objects have a :meth:`~regions.PixelRegion.to_mask` method that returns a :class:`~regions.RegionMask` object that contains information about whether pixels are inside the region, and can be used to mask data arrays: >>> from regions.core import PixCoord >>> from regions.shapes.circle import CirclePixelRegion >>> center = PixCoord(4., 5.) >>> reg = CirclePixelRegion(center, 2.3411) >>> mask = reg.to_mask() >>> mask.data array([[0., 1., 1., 1., 0.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [0., 1., 1., 1., 0.]]) The mask data contains floating point that are between 0 (no overlap) and 1 (overlap). By default, this is determined by looking only at the central position in each pixel, and:: >>> reg.to_mask() # doctest: +IGNORE_OUTPUT is equivalent to:: >>> reg.to_mask(mode='center') # doctest: +IGNORE_OUTPUT but other modes are available: * ``mode='exact'``: the overlap is determined using the exact geometrical overlap between pixels and the region. This is slower than using the central position, but allows partial overlap to be treated correctly. * ``mode='subpixels'``: the overlap is determined by sub-sampling the pixel using a grid of sub-pixels. The number of sub-pixels to use in this mode should be given using the ``subpixels`` argument. Here are what the different modes look like: .. plot:: :include-source: import matplotlib.pyplot as plt from regions.core import PixCoord from regions.shapes.circle import CirclePixelRegion center = PixCoord(26.6, 27.2) reg = CirclePixelRegion(center, 5.2) plt.figure(figsize=(6, 6)) mask1 = reg.to_mask(mode='center') plt.subplot(2, 2, 1) plt.title("mode='center'", size=9) plt.imshow(mask1.data, cmap=plt.cm.viridis, interpolation='nearest', origin='lower') mask2 = reg.to_mask(mode='exact') plt.subplot(2, 2, 2) plt.title("mode='exact'", size=9) plt.imshow(mask2.data, cmap=plt.cm.viridis, interpolation='nearest', origin='lower') mask3 = reg.to_mask(mode='subpixels', subpixels=3) plt.subplot(2, 2, 3) plt.title("mode='subpixels', subpixels=3", size=9) plt.imshow(mask3.data, cmap=plt.cm.viridis, interpolation='nearest', origin='lower') mask4 = reg.to_mask(mode='subpixels', subpixels=20) plt.subplot(2, 2, 4) plt.title("mode='subpixels', subpixels=20", size=9) plt.imshow(mask4.data, cmap=plt.cm.viridis, interpolation='nearest', origin='lower') As we've seen above, the :class:`~regions.RegionMask` objects have a ``data`` attribute that contains a Numpy array with the mask values. However, if you have for example a circular region with a radius of 3 pixels at a pixel position of (1000, 1000), it would be inefficient to store a mask that has a size larger than this, so instead we store the mask using the minimal array that contains the mask, and the :class:`~regions.RegionMask` objects also include a ``bbox`` attribute that is a :class:`~regions.BoundingBox` object used to indicate where the mask should be applied in an image. Defining a region mask within an image -------------------------------------- :class:`~regions.RegionMask` objects also have a number of methods to make it easy to use the masks with data. The :meth:`~regions.RegionMask.to_image` method can be used to obtain an image of the mask in a 2D array of the given shape. This places the mask in the correct place in the image and deals properly with boundary effects. For this example, let's place the mask in an image with shape (50, 50): .. plot:: :include-source: import matplotlib.pyplot as plt from regions.core import PixCoord from regions.shapes.circle import CirclePixelRegion center = PixCoord(26.6, 27.2) reg = CirclePixelRegion(center, 5.2) mask = reg.to_mask(mode='exact') plt.figure(figsize=(4, 4)) shape = (50, 50) plt.imshow(mask.to_image(shape), cmap=plt.cm.viridis, interpolation='nearest', origin='lower') Making image cutouts and multiplying the region mask ---------------------------------------------------- The :meth:`~regions.RegionMask.cutout` method can be used to create a cutout from the input data over the mask bounding box, and the :meth:`~regions.RegionMask.multiply` method can be used to multiply the aperture mask with the input data to create a mask-weighted data cutout. All of these methods properly handle the cases of partial or no overlap of the aperture mask with the data. These masks can be used as the building blocks for photometry, which we demonstrate with a simple example. We start off by getting an example image:: >>> from astropy.io import fits >>> from astropy.utils.data import get_pkg_data_filename >>> filename = get_pkg_data_filename('photometry/M6707HH.fits') # doctest: +IGNORE_OUTPUT >>> pf = fits.open(filename) >>> hdu = pf[0] We then define the aperture:: >>> from regions.core import PixCoord >>> from regions.shapes.circle import CirclePixelRegion >>> center = PixCoord(158.5, 1053.5) >>> aperture = CirclePixelRegion(center, 4.) We convert the aperture to a mask and extract a cutout from the data, as well as a cutout with the data multiplied by the mask:: >>> mask = aperture.to_mask(mode='exact') >>> data = mask.cutout(hdu.data) >>> weighted_data = mask.multiply(hdu.data) >>> pf.close() We can take a look at the results to make sure the source overlaps with the aperture:: .. doctest-skip:: >>> import matplotlib.pyplot as plt >>> plt.subplot(1, 3, 1) >>> plt.title("Mask", size=9) >>> plt.imshow(mask.data, cmap=plt.cm.viridis, ... interpolation='nearest', origin='lower', ... extent=mask.bbox.extent) >>> plt.subplot(1,3,2) >>> plt.title("Data cutout", size=9) >>> plt.imshow(data, cmap=plt.cm.viridis, ... interpolation='nearest', origin='lower', ... extent=mask.bbox.extent) >>> plt.subplot(1,3,3) >>> plt.title("Data cutout multiplied by mask", size=9) >>> plt.imshow(weighted_data, cmap=plt.cm.viridis, ... interpolation='nearest', origin='lower', ... extent=mask.bbox.extent) .. plot:: :context: reset :align: center from astropy.io import fits from astropy.utils.data import get_pkg_data_filename filename = get_pkg_data_filename('photometry/M6707HH.fits') pf = fits.open(filename) hdu = pf[0] from regions.core import PixCoord from regions.shapes.circle import CirclePixelRegion center = PixCoord(158.5, 1053.5) aperture = CirclePixelRegion(center, 4.) mask = aperture.to_mask(mode='exact') data = mask.cutout(hdu.data) weighted_data = mask.multiply(hdu.data) import matplotlib.pyplot as plt plt.subplot(1,3,1) plt.title("Mask", size=9) plt.imshow(mask.data, cmap=plt.cm.viridis, interpolation='nearest', origin='lower', extent=mask.bbox.extent) plt.subplot(1,3,2) plt.title("Data cutout", size=9) plt.imshow(data, cmap=plt.cm.viridis, interpolation='nearest', origin='lower', extent=mask.bbox.extent) plt.subplot(1,3,3) plt.title("Data cutout multiplied by mask", size=9) plt.imshow(weighted_data, cmap=plt.cm.viridis, interpolation='nearest', origin='lower', extent=mask.bbox.extent) We can also use the `~regions.RegionMask` ``bbox`` attribute to look at the extent of the mask in the image: .. plot:: :context: :include-source: :align: center ax = plt.subplot(1, 1, 1) ax.imshow(hdu.data, cmap=plt.cm.viridis, interpolation='nearest', origin='lower') ax.add_artist(mask.bbox.as_artist(facecolor='none', edgecolor='white')) ax.add_artist(aperture.as_artist(facecolor='none', edgecolor='orange')) ax.set_xlim(120, 180) ax.set_ylim(1000, 1059) .. plot:: :context: :nofigs: pf.close() Finally, we can use the mask and data values to compute weighted statistics:: >>> import numpy as np >>> np.average(data, weights=mask) # doctest: +FLOAT_CMP 9364.012674888021 regions-0.4/docs/plot_compound.py0000644000076600000240000000400313501414013017235 0ustar deilstaff00000000000000""" Example script illustrating compound regions. """ import numpy as np import matplotlib.pyplot as plt from astropy.coordinates import SkyCoord, Angle from regions import CircleSkyRegion, make_example_dataset # load example dataset to get skymap config = dict(crval=(0, 0), crpix=(180, 90), cdelt=(-1, 1), shape=(180, 360)) dataset = make_example_dataset(data='simulated', config=config) wcs = dataset.wcs # remove sources dataset.image.data = np.zeros_like(dataset.image.data) # define 2 sky circles circle1 = CircleSkyRegion( center=SkyCoord(20, 0, unit='deg', frame='galactic'), radius=Angle('30 deg') ) circle2 = CircleSkyRegion( center=SkyCoord(50, 45, unit='deg', frame='galactic'), radius=Angle('30 deg'), ) # define skycoords lon = np.arange(-180, 181, 10) lat = np.arange(-90, 91, 10) coords = np.array(np.meshgrid(lon, lat)).T.reshape(-1, 2) skycoords = SkyCoord(coords, unit='deg', frame='galactic') # get events in AND and XOR compound_and = circle1 & circle2 compound_xor = circle1 ^ circle2 mask_and = compound_and.contains(skycoords, wcs) skycoords_and = skycoords[mask_and] mask_xor = compound_xor.contains(skycoords, wcs) skycoords_xor = skycoords[mask_xor] # plot fig = plt.figure() ax = fig.add_axes([0.15, 0.1, 0.8, 0.8], projection=wcs, aspect='equal') ax.scatter(skycoords.l.value, skycoords.b.value, label='all', transform=ax.get_transform('galactic')) ax.scatter(skycoords_xor.l.value, skycoords_xor.b.value, color='orange', label='xor', transform=ax.get_transform('galactic')) ax.scatter(skycoords_and.l.value, skycoords_and.b.value, color='magenta', label='and', transform=ax.get_transform('galactic')) circle1.to_pixel(wcs=wcs).plot(ax=ax, edgecolor='green', facecolor='none', alpha=0.8, lw=3) circle2.to_pixel(wcs=wcs).plot(ax=ax, edgecolor='red', facecolor='none', alpha=0.8, lw=3) ax.legend(loc='lower right') ax.set_xlim(-0.5, dataset.config['shape'][1] - 0.5) ax.set_ylim(-0.5, dataset.config['shape'][0] - 0.5) regions-0.4/docs/plot_example.py0000644000076600000240000000200013501414013017037 0ustar deilstaff00000000000000"""Example how to plot sky regions on a sky image. """ from astropy.coordinates import SkyCoord, Angle from regions import ( make_example_dataset, CircleSkyRegion, ) import matplotlib.pyplot as plt config = dict(crpix=(18, 9), cdelt=(-10, 10), shape=(18, 36)) dataset = make_example_dataset(data='simulated', config=config) wcs = dataset.wcs fig = plt.figure() ax = fig.add_axes([0.15, 0.1, 0.8, 0.8], projection=wcs) ax.set_xlim(-0.5, dataset.config['shape'][1] - 0.5) ax.set_ylim(-0.5, dataset.config['shape'][0] - 0.5) ax.imshow(dataset.image.data, cmap='gray', vmin=0, vmax=1, interpolation='nearest', origin='lower') for source in dataset.source_table: # Plot a sky circle around each source center = SkyCoord(source['GLON'], source['GLAT'], unit='deg', frame='galactic') radius = Angle(20, 'deg') region = CircleSkyRegion(center=center, radius=radius) pix_region = region.to_pixel(wcs=wcs) pix_region.plot(ax=ax, edgecolor='yellow', facecolor='yellow', alpha=0.5, lw=3) regions-0.4/docs/plot_example_pix.py0000644000076600000240000000062213501414013017727 0ustar deilstaff00000000000000"""Example how to plot pixel regions on an image without WCS. """ import numpy as np import matplotlib.pyplot as plt from regions import PixCoord, CirclePixelRegion fig, ax = plt.subplots() region = CirclePixelRegion(center=PixCoord(x=3, y=5), radius=3) data = np.arange(10 * 15).reshape((10, 15)) ax.imshow(data, cmap='gray', interpolation='nearest', origin='lower') region.plot(ax=ax, color='red') regions-0.4/docs/plot_reg.py0000644000076600000240000000113213501414013016166 0ustar deilstaff00000000000000from matplotlib import pyplot as plt from astropy.utils.data import get_pkg_data_filename from astropy.io import fits from regions import read_ds9 image_file = get_pkg_data_filename('tutorials/FITS-images/HorseHead.fits') print(image_file) image_data = fits.getdata(image_file, ext=0, memmap=False) ax = plt.gca() plt.imshow(image_data, cmap='gray') print(ax.get_xlim(), ax.get_ylim()) ax.set_ylim([-0.5, 892.5]) regs = read_ds9(get_pkg_data_filename('data/plot_image.reg', package='regions.io.ds9.tests')) for i, reg in enumerate(regs): reg.plot(ax=ax) regions-0.4/docs/plotting.rst0000644000076600000240000000506113501414013016400 0ustar deilstaff00000000000000.. _gs-mpl: Plotting regions with Matplotlib ================================ Some `~regions.PixelRegion` objects have an ``as_artist()`` method that returns an equivalent `matplotlib.patches` object. For example :meth:`regions.CirclePixelRegion.as_artist` returns a `matplotlib.patches.Circle` object. To draw a matplotlib patch object, add it to an `matplotlib.axes.Axes` object. .. plot:: :include-source: from regions import PixCoord, CirclePixelRegion import matplotlib.pyplot as plt region = CirclePixelRegion(PixCoord(x=0.3, y=0.42), radius=0.5) artist = region.as_artist() axes = plt.gca() axes.set_aspect('equal') axes.add_artist(artist) axes.set_xlim([-0.5, 1]) axes.set_ylim([-0.5, 1]) The :meth:`~regions.PixelRegion.plot`, a convenience method just does these two steps at once (creating a matplotlib patch artist and adding it to an axis), and calls ``plt.gca()`` if no axis is passed in. You can shift the origin of the region very conveniently while plotting by simply supplying the ``origin`` pixel coordinates to :meth:`~regions.PixelRegion.plot` and :meth:`~regions.PixelRegion.as_artist`. The ``**kwargs`` argument takes any keyword argument that the `~matplotlib.patches.Patch` object accepts for those regions represented as patches, or arguments `~matplotlib.lines.Line2D` accepts for point regions. For example: .. plot:: :include-source: from regions import PixCoord, BoundingBox import matplotlib.pyplot as plt bbox = BoundingBox(ixmin=-1, ixmax=1, iymin=-2, iymax=2) # shifting the origin to (1, 1) pixel position ax = bbox.plot(origin=(1, 1), edgecolor='yellow', facecolor='red', fill=True) ax.set_xlim([-4, 2]) ax.set_ylim([-4, 2]) Here's a full example how to plot a `~regions.CirclePixelRegion` on an image. .. plot:: plot_example_pix.py :include-source: The `~regions.RectanglePixelRegion` and `~regions.EllipsePixelRegion` docstrings also contain plot examples. `~regions.SkyRegion` objects currently don't have an ``as_artist()`` or ``plot()`` method. To plot them, convert them to a pixel region first: .. code-block:: python sky_region = <...> pixel_region = sky_region.to_pixel(wcs, mode, tolerance) pixel_region.plot(**kwargs) # plot options passed to matplotlib We do plan to add extensive documentation on sky region plotting, or to add methods on sky region to do it directly in the future (see https://github.com/astropy/regions/issues/76 ), after the polygon region classes are developed. An example of how to plot sky regions on a sky image is shown above. regions-0.4/docs/references.txt0000644000076600000240000000106313336761120016700 0ustar deilstaff00000000000000.. _pyregion: http://pyregion.readthedocs.io/en/latest/ .. _spherical_geometry: http://spacetelescope.github.io/sphere/spherical_geometry/index.html .. _photutils: http://photutils.readthedocs.io/en/latest/aperture.html .. _matplotlib: https://matplotlib.org/ .. _shapely: http://toblerity.org/shapely/manual.html .. _Github repository: https://github.com/astropy/regions .. _Region documentation: http://astropy-regions.readthedocs.io/en/latest/ .. _affiliated package: http://www.astropy.org/affiliated/index.html .. _get help: http://www.astropy.org/help.html regions-0.4/docs/shapely.rst0000644000076600000240000000317313501414013016207 0ustar deilstaff00000000000000.. _gs-shapely: Converting regions to shapely objects ===================================== The `Shapely `__ Python package is a generic package for the manipulation and analysis of geometric objects in the Cartesian plane. Concerning regions in the cartesian plane, it is more feature-complete, powerful and optimized than this ``regions`` package. The use of Shapely or other Python regions packages that come from the geospatial domain in Astronomy is rare. However, if you have a complex pixel region analysis task, you can consider using Shapely. Either use it directly, by defining Shapely regions via Python code or one of the serialisation formats they support, or by writing some Python code to convert ``astropy-regions`` objects to Shapely objects. Here we give one example how to do this: convert a circle to a Shapely object and polygonise it. That's one nice feature of Shapely, it can polygonise all shapes and do fast polygon-based computations like intersection and union. If you need to do this, that's a good reason to use Shapely. .. plot:: :include-source: import matplotlib.pyplot as plt from regions import PixCoord, CirclePixelRegion # Make an example region region = CirclePixelRegion(center=PixCoord(3, 2), radius=2) # Convert to Shapely from shapely.geometry import Point point = Point(region.center.x, region.center.y) circle = point.buffer(region.radius) # Actually, this is a polygon approximation of the circle! print(circle) # Plot the result x, y = circle.exterior.xy ax = plt.subplot(1, 1, 1) ax.plot(x, y, 'g-') regions-0.4/docs/shapes.rst0000644000076600000240000003552613501414013016034 0ustar deilstaff00000000000000.. include:: references.txt .. testsetup: >>> from regions import make_example_dataset >>> dataset = make_example_dataset(data='simulated') >>> wcs = dataset.wcs .. _sh: .. _sh-shapes: Shapes ====== This section shows one example how to construct a region for each shape that's currently supported. * `~regions.CircleSkyRegion` and `~regions.CirclePixelRegion` .. code-block:: python >>> from astropy.coordinates import SkyCoord >>> from astropy import units as u >>> from regions import PixCoord, CircleSkyRegion, CirclePixelRegion >>> center_sky = SkyCoord(42, 43, unit='deg', frame='fk5') >>> circle_sky = CircleSkyRegion(center=center_sky, radius=3 * u.deg) >>> circle_pix = CirclePixelRegion(center=PixCoord(x=42, y=43), ... radius=4.2) * `~regions.CircleAnnulusSkyRegion` and `~regions.CircleAnnulusPixelRegion` .. code-block:: python >>> from astropy.coordinates import SkyCoord >>> from astropy import units as u >>> from regions import PixCoord, CircleAnnulusSkyRegion, CircleAnnulusPixelRegion >>> center_sky = SkyCoord(42, 43, unit='deg', frame='fk5') >>> circle_annulus_sky = CircleAnnulusSkyRegion(center=center_sky, ... inner_radius=3 * u.deg, ... outer_radius=4 * u.deg) >>> circle_annulus_pix = CircleAnnulusPixelRegion(center=PixCoord(x=42, y=43), ... inner_radius=4.2, ... outer_radius=5.2) * `~regions.EllipseSkyRegion` and `~regions.EllipsePixelRegion` .. code-block:: python >>> from astropy.coordinates import SkyCoord >>> from astropy import units as u >>> from regions import PixCoord, EllipseSkyRegion, EllipsePixelRegion >>> center_sky = SkyCoord(42, 43, unit='deg', frame='fk5') >>> ellipse_sky = EllipseSkyRegion(center=center_sky, ... height=3 * u.deg, width=3 * u.deg, ... angle=5 * u.deg) >>> ellipse_pix = EllipsePixelRegion(center=PixCoord(x=42, y=43), ... height=4.2, width=4.2, ... angle=5 * u.deg) * `~regions.EllipseAnnulusSkyRegion` and `~regions.EllipseAnnulusPixelRegion` .. code-block:: python >>> from astropy.coordinates import SkyCoord >>> from astropy import units as u >>> from regions import PixCoord, EllipseAnnulusSkyRegion, EllipseAnnulusPixelRegion >>> center_sky = SkyCoord(42, 43, unit='deg', frame='fk5') >>> ellipse_annulus_sky = EllipseAnnulusSkyRegion(center=center_sky, ... inner_width=3 * u.deg, ... outer_width=4 * u.deg, ... inner_height=6 * u.deg, ... outer_height=7 * u.deg, ... angle=6 * u.deg) >>> ellipse_annulus_pix = EllipseAnnulusPixelRegion(center=PixCoord(x=42, y=43), ... inner_width=4.2, ... outer_width=5.2, ... inner_height=7.2, ... outer_height=8.2, ... angle=6 * u.deg) * `~regions.PointSkyRegion` and `~regions.PointPixelRegion` .. code-block:: python >>> from astropy.coordinates import SkyCoord >>> from regions import PixCoord, PointSkyRegion, PointPixelRegion >>> center_sky = SkyCoord(42, 43, unit='deg', frame='fk5') >>> point_sky = PointSkyRegion(center=center_sky) >>> point_pix = PointPixelRegion(center=PixCoord(x=42, y=43)) * `~regions.TextSkyRegion` and `~regions.TextPixelRegion` .. code-block:: python >>> from astropy.coordinates import SkyCoord >>> from regions import PixCoord, TextSkyRegion, TextPixelRegion >>> center_sky = SkyCoord(42, 43, unit='deg', frame='fk5') >>> point_sky = TextSkyRegion(center=center_sky, text='Demo Text') >>> point_pix = TextPixelRegion(center=PixCoord(x=42, y=43), text='Demo Text') * `~regions.LineSkyRegion` and `~regions.LinePixelRegion` .. code-block:: python >>> from astropy.coordinates import SkyCoord >>> from regions import PixCoord, LineSkyRegion, LinePixelRegion >>> start_sky = SkyCoord(42, 43, unit='deg', frame='fk5') >>> end_sky = SkyCoord(52, 53, unit='deg', frame='fk5') >>> line_sky = LineSkyRegion(start=start_sky, end=end_sky) >>> line_pix = LinePixelRegion(start=PixCoord(x=42, y=43), end=PixCoord(x=52, y=53)) * `~regions.RectangleSkyRegion` and `~regions.RectanglePixelRegion` .. code-block:: python >>> from astropy.coordinates import SkyCoord >>> from astropy import units as u >>> from regions import PixCoord, RectangleSkyRegion, RectanglePixelRegion >>> center_sky = SkyCoord(42, 43, unit='deg', frame='fk5') >>> rectangle_sky = RectangleSkyRegion(center=center_sky, ... width=3 * u.deg, height=4 * u.deg, ... angle=5 * u.deg) >>> rectangle_pix = RectanglePixelRegion(center=PixCoord(x=42, y=43), ... width=3, height=4, ... angle=5 * u.deg) * `~regions.RectangleAnnulusSkyRegion` and `~regions.RectangleAnnulusPixelRegion` .. code-block:: python >>> from astropy.coordinates import SkyCoord >>> from astropy import units as u >>> from regions import PixCoord, RectangleAnnulusSkyRegion, RectangleAnnulusPixelRegion >>> center_sky = SkyCoord(42, 43, unit='deg', frame='fk5') >>> rectangle_annulus_sky = RectangleAnnulusSkyRegion(center=center_sky, ... inner_width=3 * u.deg, ... outer_width=4 * u.deg, ... inner_height=6 * u.deg, ... outer_height=7 * u.deg, ... angle=15 * u.deg) >>> rectangle_annulus_pix = RectangleAnnulusPixelRegion(center=PixCoord(x=42, y=43), ... inner_width=4.2, ... outer_width=5.2, ... inner_height=7.2, ... outer_height=8.2, ... angle=15 * u.deg) * `~regions.PolygonSkyRegion` and `~regions.PolygonPixelRegion` .. code-block:: python >>> from astropy.coordinates import SkyCoord >>> from regions import PixCoord, PolygonSkyRegion, PolygonPixelRegion >>> polygon_sky = PolygonSkyRegion(vertices=SkyCoord([1, 2, 2], [1, 1, 2], unit='deg', frame='fk5')) >>> polygon_pix = PolygonPixelRegion(vertices=PixCoord(x=[1, 2, 2], y=[1, 1, 2])) .. .. _sh-poly: .. .. Polygons .. -------- .. .. Polygons are the most versatile region, since any region can be approximated .. as a polygon. .. .. TODO: explain how polygons are implemented and special polygon methods, .. e.g. how to obtain a polygon approximation for any shape. .. This is not available yet, for now see `spherical_geometry`_ .. for spherical polygons and `Shapely`_ for pixel polygons. .. _sh-wcs: Transformations --------------- In the last two sections, we talked about how for every region shape (e.g. circle), there are two classes, one representing "sky regions" and another representing "pixel regions" on a given image. A key feature of the regions package is that, for a given image, more precisely a given `~astropy.wcs.WCS` object, it is possible to convert back and forth between sky and image regions. As an example, let's use this :class:`~regions.CircleSkyRegion`, a sky circle region: .. code-block:: python >>> from astropy.coordinates import Angle, SkyCoord >>> from regions import CircleSkyRegion >>> center = SkyCoord(50, 10, unit='deg') >>> radius = Angle(30, 'deg') >>> sky_reg = CircleSkyRegion(center, radius) To convert it to a :class:`~regions.PixelRegion`, call the :meth:`~regions.SkyRegion.to_pixel` method: .. code-block:: python >>> pix_reg = sky_reg.to_pixel(wcs) >>> print(pix_reg) # doctest: +FLOAT_CMP Region: CirclePixelRegion center: PixCoord(x=55.35205711214607, y=40.0958313892697) radius: 36.93290808340659 Also to convert a :class:`~regions.PixelRegion` to a :class:`~regions.SkyRegion`, call the :meth:`~regions.PixelRegion.to_sky` method: .. code-block:: python >>> sky_reg = pix_reg.to_sky(wcs) >>> print(sky_reg) # doctest: +FLOAT_CMP Region: CircleSkyRegion center: radius: 18.55481729935556 deg .. _sh-meta: Meta Data --------- A :class:`~regions.Region` has ``meta`` and ``visual`` attributes which stores the meta data of the region. Since this package supports various file formats it is necessary to handle the meta attributes supported by them. To handle them there are :class:`~regions.RegionMeta` and :class:`~regions.RegionVisual` for meta and visual attributes respectively. They are subclasses of the python dictionary (`~dict`). The meta attribute provides additional data about regions such as labels, tags, comments, name, etc. which are used for non-display tasks. It also stores the spectral dimensions of the region. These classes, for now, just check whether the key is valid or not. The valid keys for :class:`~regions.RegionMeta` class are: 1. ``label``: - CRTF, DS9 (text label for a region) - Ex: meta['label'] = 'this is a circle' 2. ``tag``: - DS9 (All regions may have zero or more tags associated with it, which may be used for grouping and searching.) - Ex: meta['tags'] = ['{Group 1}', '{Group 2}']} 3. ``include``: - CRTF, DS9 (Region inclusion) - Possible Values: True, False - Ex: meta['include'] = True 4. ``frame``: - CRTF (Frequency/Velocity Axis) - Possible values: 'REST', 'LSRK', 'LSRD', 'BARY', 'GEO', 'TOPO', 'GALACTO', 'LGROUP', 'CMB' - Default: image value - Ex: meta['frame'] = 'TOPO' 5. ``range``: - CRTF (Frequency/Velocity Range) - Possible units: GHz, MHz, kHz, km/s, Hz, channel, chan (=channel) - Default: image range - Format: [min, max] - Ex: meta['range'] = [-320 * u.m/u.sec, -330 * u.m/u.s] 6. ``veltype``: - CRTF (Velocity Calculation) - Possible values: 'RADIO', 'OPTICAL', 'Z', 'BETA', 'GAMMA' - Default: image value - Ex: meta['veltype'] = 'RADIO' 7. ``restfreq``: - CRTF (Rest Frequency) - Possible values: `~astropy.units.Quantity` object - Default: image value - Ex: meta['restfreq'] = Quantity("1.42GHz") 8. ``corr``: - CRTF (Correlational Axis) - Possible values: 'I', 'Q', 'U', 'V', 'RR', 'RL', 'LR', 'LL', 'XX', 'XY', 'YX', 'YY', 'RX', 'RY', 'LX', 'LY', 'XR', 'XL', 'YR', 'YL', 'PP', 'PQ', 'QP', 'QQ', 'RCircular', 'LCircular', 'Linear', 'Ptotal', 'Plinear', 'PFtotal', 'PFlinear', 'Pangle' - Default: all planes present in image - Ex: meta['corr'] = ['X', 'Y'] 9. ``comment``: - DS9, CRTF (Comment on the region) - Ex: meta['comment'] = 'Any comment for the region' 11. ``line``: - DS9 (The line region may be rendered with arrows, one at each end. To indicate arrows, use the line property. A '1' indicates an arrow, '0' indicates no arrow.) - Ex: meta['line'] = [1, 1] 12. ``name`` 13. ``select`` 14. ``highlite`` 15. ``fixed`` 16. ``edit``: - DS9 (The Edit property specifies if the user is allowed to edit the region via the GUI.) - Ex: meta['edit'] = 1 17. ``move``: - DS9 (The Move property specifies if the user is allowed to move the region via the GUI. ) - Ex: meta['move'] = 1 18. ``rotate``: - DS9 (The Rotate property specifies if the user is allowed to rotate the region via the GUI. ) - Ex: meta['rotate'] = 1 19. ``delete``: - DS9 (The Delete property specifies if the user is allowed to delete the region via the GUI. ) - Ex: meta['delete'] = 1 20. ``source`` 21. ``background`` The visual attributes are meta data meant to be used to visualize regions, especially used by plotting libraries such as `Matplotlib`_ . The valid keys for `~regions.RegionVisual` class are: 1. ``color``: CRTF, DS9 (Region, symbol and text color) - Possible values: any color recognized by `Matplotlib`_, including hex values - Default: color=green - Ex: visual['color'] = 'blue' 2. ``dash``: Render region using dashed lines using current dashlist value. 3. ``font``: Name of the font. 4. ``dashlist``: Sets dashed line parameters. This does not render the region in dashed lines. 5. ``symsize``: Size of the symbol 6. ``symthick``: Thickness of the symbol 7. ``fontsize``: Size of the font. 8. ``fontstyle``: Style of the font. 9. ``usetex``: Boolean value whether the label uses tex. 10. ``labelpos``: position of the label 11. ``labeloff``: label offset 12. ``linewidth``: width of the line 13. ``linestyle``: style of the line 14. ``fill``: Boolean value whether the regions is filled 15. ``line``: The line region may be rendered with arrows, one at each end. To indicate arrows, use the line property. A '1' indicates an arrow, '0' indicates no arrow. 16. ``symbol``/``point``: CRTF, DS9 (Symbol for which a point region is described) - Ex: meta['symbol'] = 'point marker' .. _sh-lists: Lists ----- A `~regions.Region` object can only represent one region, not an array (a.k.a. vector or list) of regions. This is in contrast to the aperture classes in `photutils` like :class:`~photutils.CircularAperture` that do allow the ``positions`` (but usually not the other parameters) to be arrays: .. doctest-skip:: >>> from photutils import CircularAperture >>> positions = [(1, 2), (3, 4)] >>> apertures = CircularAperture(positions, r=4.2) To represent lists of `~regions.Region` objects, you can store them in Python lists (or other containers, but lists are the most common). To create many similar regions or process many regions you can use for loops or list comprehensions. .. code-block:: python >>> from regions import PixCoord, CirclePixelRegion >>> regions = [ ... CirclePixelRegion(center=PixCoord(x, y), radius=4.2) ... for x, y in [(1, 2), (3, 4)] ... ] >>> for region in regions: ... print(region.center) PixCoord(x=1, y=2) PixCoord(x=3, y=4) >>> [region.area for region in regions] [55.41769440932395, 55.41769440932395] regions-0.4/regions/0000755000076600000240000000000013501657425014542 5ustar deilstaff00000000000000regions-0.4/regions/__init__.py0000644000076600000240000000157713477731541016671 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ This is an in-development package for region handling based on Astropy. The goal is to merge the functionality from pyregion and photutils apertures and then after some time propose this package for inclusion in the Astropy core. * Code : https://github.com/astropy/regions * Docs : http://astropy-regions.readthedocs.io/en/latest/ """ # Affiliated packages may add whatever they like to this file, but # should keep this content at the top. # ---------------------------------------------------------------------------- from ._astropy_init import * # ---------------------------------------------------------------------------- # For egg_info test builds to pass, put package imports here. if not _ASTROPY_SETUP_: from ._utils.examples import * from .core import * from .shapes import * from .io import * regions-0.4/regions/_astropy_init.py0000644000076600000240000000374713477731541020016 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst __all__ = ['__version__', '__githash__'] # this indicates whether or not we are in the package's setup.py try: _ASTROPY_SETUP_ except NameError: from sys import version_info if version_info[0] >= 3: import builtins else: import __builtin__ as builtins builtins._ASTROPY_SETUP_ = False try: from .version import version as __version__ except ImportError: __version__ = '' try: from .version import githash as __githash__ except ImportError: __githash__ = '' if not _ASTROPY_SETUP_: # noqa import os from warnings import warn from astropy.config.configuration import ( update_default_config, ConfigurationDefaultMissingError, ConfigurationDefaultMissingWarning) # Create the test function for self test from astropy.tests.runner import TestRunner test = TestRunner.make_test_runner_in(os.path.dirname(__file__)) test.__test__ = False __all__ += ['test'] # add these here so we only need to cleanup the namespace at the end config_dir = None if not os.environ.get('ASTROPY_SKIP_CONFIG_UPDATE', False): config_dir = os.path.dirname(__file__) config_template = os.path.join(config_dir, __package__ + ".cfg") if os.path.isfile(config_template): try: update_default_config( __package__, config_dir, version=__version__) except TypeError as orig_error: try: update_default_config(__package__, config_dir) except ConfigurationDefaultMissingError as e: wmsg = (e.args[0] + " Cannot install default profile. If you are " "importing from source, this is expected.") warn(ConfigurationDefaultMissingWarning(wmsg)) del e except Exception: raise orig_error regions-0.4/regions/_compiler.c0000644000076600000240000000573113501657416016665 0ustar deilstaff00000000000000#include /*************************************************************************** * Macros for determining the compiler version. * * These are borrowed from boost, and majorly abridged to include only * the compilers we care about. ***************************************************************************/ #ifndef PY3K #if PY_MAJOR_VERSION >= 3 #define PY3K 1 #else #define PY3K 0 #endif #endif #define STRINGIZE(X) DO_STRINGIZE(X) #define DO_STRINGIZE(X) #X #if defined __clang__ /* Clang C++ emulates GCC, so it has to appear early. */ # define COMPILER "Clang version " __clang_version__ #elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC) /* Intel */ # if defined(__INTEL_COMPILER) # define INTEL_VERSION __INTEL_COMPILER # elif defined(__ICL) # define INTEL_VERSION __ICL # elif defined(__ICC) # define INTEL_VERSION __ICC # elif defined(__ECC) # define INTEL_VERSION __ECC # endif # define COMPILER "Intel C compiler version " STRINGIZE(INTEL_VERSION) #elif defined(__GNUC__) /* gcc */ # define COMPILER "GCC version " __VERSION__ #elif defined(__SUNPRO_CC) /* Sun Workshop Compiler */ # define COMPILER "Sun compiler version " STRINGIZE(__SUNPRO_CC) #elif defined(_MSC_VER) /* Microsoft Visual C/C++ Must be last since other compilers define _MSC_VER for compatibility as well */ # if _MSC_VER < 1200 # define COMPILER_VERSION 5.0 # elif _MSC_VER < 1300 # define COMPILER_VERSION 6.0 # elif _MSC_VER == 1300 # define COMPILER_VERSION 7.0 # elif _MSC_VER == 1310 # define COMPILER_VERSION 7.1 # elif _MSC_VER == 1400 # define COMPILER_VERSION 8.0 # elif _MSC_VER == 1500 # define COMPILER_VERSION 9.0 # elif _MSC_VER == 1600 # define COMPILER_VERSION 10.0 # else # define COMPILER_VERSION _MSC_VER # endif # define COMPILER "Microsoft Visual C++ version " STRINGIZE(COMPILER_VERSION) #else /* Fallback */ # define COMPILER "Unknown compiler" #endif /*************************************************************************** * Module-level ***************************************************************************/ struct module_state { /* The Sun compiler can't handle empty structs */ #if defined(__SUNPRO_C) || defined(_MSC_VER) int _dummy; #endif }; #if PY3K static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "_compiler", NULL, sizeof(struct module_state), NULL, NULL, NULL, NULL, NULL }; #define INITERROR return NULL PyMODINIT_FUNC PyInit__compiler(void) #else #define INITERROR return PyMODINIT_FUNC init_compiler(void) #endif { PyObject* m; #if PY3K m = PyModule_Create(&moduledef); #else m = Py_InitModule3("_compiler", NULL, NULL); #endif if (m == NULL) INITERROR; PyModule_AddStringConstant(m, "compiler", COMPILER); #if PY3K return m; #endif } regions-0.4/regions/_geometry/0000755000076600000240000000000013501657425016534 5ustar deilstaff00000000000000regions-0.4/regions/_geometry/__init__.py0000644000076600000240000000060613501414013020627 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ Geometry subpackage for low-level geometry functions. """ from .circular_overlap import * from .elliptical_overlap import * from .rectangular_overlap import * from .polygonal_overlap import * __all__ = ['circular_overlap_grid', 'elliptical_overlap_grid', 'rectangular_overlap_grid', 'polygonal_overlap_grid'] regions-0.4/regions/_geometry/circular_overlap.c0000644000076600000240000140462413501657420022242 0ustar deilstaff00000000000000/* Generated by Cython 0.29.6 */ #define PY_SSIZE_T_CLEAN #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_6" #define CYTHON_HEX_VERSION 0x001D06F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #ifndef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #define PyObject_Unicode PyObject_Str #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_ERR(f_index, lineno, Ln_error) \ { \ __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__regions___geometry__circular_overlap #define __PYX_HAVE_API__regions___geometry__circular_overlap /* Early includes */ #include #include #include "numpy/arrayobject.h" #include "numpy/ufuncobject.h" #include "math.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; /* Header.proto */ #if !defined(CYTHON_CCOMPLEX) #if defined(__cplusplus) #define CYTHON_CCOMPLEX 1 #elif defined(_Complex_I) #define CYTHON_CCOMPLEX 1 #else #define CYTHON_CCOMPLEX 0 #endif #endif #if CYTHON_CCOMPLEX #ifdef __cplusplus #include #else #include #endif #endif #if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) #undef _Complex_I #define _Complex_I 1.0fj #endif static const char *__pyx_f[] = { "regions/_geometry/circular_overlap.pyx", "__init__.pxd", "type.pxd", }; /* BufferFormatStructs.proto */ #define IS_UNSIGNED(type) (((type) -1) > 0) struct __Pyx_StructField_; #define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) typedef struct { const char* name; struct __Pyx_StructField_* fields; size_t size; size_t arraysize[8]; int ndim; char typegroup; char is_unsigned; int flags; } __Pyx_TypeInfo; typedef struct __Pyx_StructField_ { __Pyx_TypeInfo* type; const char* name; size_t offset; } __Pyx_StructField; typedef struct { __Pyx_StructField* field; size_t parent_offset; } __Pyx_BufFmt_StackElem; typedef struct { __Pyx_StructField root; __Pyx_BufFmt_StackElem* head; size_t fmt_offset; size_t new_count, enc_count; size_t struct_alignment; int is_complex; char enc_type; char new_packmode; char enc_packmode; char is_valid_array; } __Pyx_BufFmt_Context; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t */ typedef npy_int8 __pyx_t_5numpy_int8_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t */ typedef npy_int16 __pyx_t_5numpy_int16_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< * ctypedef npy_int64 int64_t * #ctypedef npy_int96 int96_t */ typedef npy_int32 __pyx_t_5numpy_int32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< * #ctypedef npy_int96 int96_t * #ctypedef npy_int128 int128_t */ typedef npy_int64 __pyx_t_5numpy_int64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< * ctypedef npy_uint64 uint64_t * #ctypedef npy_uint96 uint96_t */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":786 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< * #ctypedef npy_uint96 uint96_t * #ctypedef npy_uint128 uint128_t */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< * ctypedef npy_float64 float64_t * #ctypedef npy_float80 float80_t */ typedef npy_float32 __pyx_t_5numpy_float32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< * #ctypedef npy_float80 float80_t * #ctypedef npy_float128 float128_t */ typedef npy_float64 __pyx_t_5numpy_float64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t */ typedef npy_long __pyx_t_5numpy_int_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< * ctypedef npy_longlong longlong_t * */ typedef npy_longlong __pyx_t_5numpy_long_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< * * ctypedef npy_ulong uint_t */ typedef npy_longlong __pyx_t_5numpy_longlong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t */ typedef npy_ulong __pyx_t_5numpy_uint_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulonglong_t * */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":806 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< * * ctypedef npy_intp intp_t */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< * ctypedef npy_uintp uintp_t * */ typedef npy_intp __pyx_t_5numpy_intp_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":809 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< * * ctypedef npy_double float_t */ typedef npy_uintp __pyx_t_5numpy_uintp_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t */ typedef npy_double __pyx_t_5numpy_float_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< * ctypedef npy_longdouble longdouble_t * */ typedef npy_double __pyx_t_5numpy_double_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cfloat cfloat_t */ typedef npy_longdouble __pyx_t_5numpy_longdouble_t; /* "regions/_geometry/circular_overlap.pyx":26 * * DTYPE = np.float64 * ctypedef np.float64_t DTYPE_t # <<<<<<<<<<<<<< * * # NOTE: Here we need to make sure we use cimport to import the C functions from */ typedef __pyx_t_5numpy_float64_t __pyx_t_7regions_9_geometry_16circular_overlap_DTYPE_t; /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< float > __pyx_t_float_complex; #else typedef float _Complex __pyx_t_float_complex; #endif #else typedef struct { float real, imag; } __pyx_t_float_complex; #endif static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< double > __pyx_t_double_complex; #else typedef double _Complex __pyx_t_double_complex; #endif #else typedef struct { double real, imag; } __pyx_t_double_complex; #endif static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); /*--- Type declarations ---*/ /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< * ctypedef npy_clongdouble clongdouble_t * */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":817 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cdouble complex_t */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":819 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew1(a): */ typedef npy_cdouble __pyx_t_5numpy_complex_t; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* IsLittleEndian.proto */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); /* BufferFormatCheck.proto */ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type); /* BufferGetAndValidate.proto */ #define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ ((obj == Py_None || obj == NULL) ?\ (__Pyx_ZeroBuffer(buf), 0) :\ __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); static void __Pyx_ZeroBuffer(Py_buffer* buf); static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; /* BufferIndexError.proto */ static void __Pyx_RaiseBufferIndexError(int axis); #define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1) /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto #define __PYX_HAVE_RT_ImportType_proto enum __Pyx_ImportType_CheckSize { __Pyx_ImportType_CheckSize_Error = 0, __Pyx_ImportType_CheckSize_Warn = 1, __Pyx_ImportType_CheckSize_Ignore = 2 }; static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* BufferStructDeclare.proto */ typedef struct { Py_ssize_t shape, strides, suboffsets; } __Pyx_Buf_DimInfo; typedef struct { size_t refcount; Py_buffer pybuffer; } __Pyx_Buffer; typedef struct { __Pyx_Buffer *rcbuffer; char *data; __Pyx_Buf_DimInfo diminfo[8]; } __Pyx_LocalBuf_ND; #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); static void __Pyx_ReleaseBuffer(Py_buffer *view); #else #define __Pyx_GetBuffer PyObject_GetBuffer #define __Pyx_ReleaseBuffer PyBuffer_Release #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus #define __Pyx_CREAL(z) ((z).real()) #define __Pyx_CIMAG(z) ((z).imag()) #else #define __Pyx_CREAL(z) (__real__(z)) #define __Pyx_CIMAG(z) (__imag__(z)) #endif #else #define __Pyx_CREAL(z) ((z).real) #define __Pyx_CIMAG(z) ((z).imag) #endif #if defined(__cplusplus) && CYTHON_CCOMPLEX\ && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) #define __Pyx_SET_CREAL(z,x) ((z).real(x)) #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) #else #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_float(a, b) ((a)==(b)) #define __Pyx_c_sum_float(a, b) ((a)+(b)) #define __Pyx_c_diff_float(a, b) ((a)-(b)) #define __Pyx_c_prod_float(a, b) ((a)*(b)) #define __Pyx_c_quot_float(a, b) ((a)/(b)) #define __Pyx_c_neg_float(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_float(z) ((z)==(float)0) #define __Pyx_c_conj_float(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_float(z) (::std::abs(z)) #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_float(z) ((z)==0) #define __Pyx_c_conj_float(z) (conjf(z)) #if 1 #define __Pyx_c_abs_float(z) (cabsf(z)) #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); #endif #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_double(a, b) ((a)==(b)) #define __Pyx_c_sum_double(a, b) ((a)+(b)) #define __Pyx_c_diff_double(a, b) ((a)-(b)) #define __Pyx_c_prod_double(a, b) ((a)*(b)) #define __Pyx_c_quot_double(a, b) ((a)/(b)) #define __Pyx_c_neg_double(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_double(z) ((z)==(double)0) #define __Pyx_c_conj_double(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_double(z) (::std::abs(z)) #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_double(z) ((z)==0) #define __Pyx_c_conj_double(z) (conj(z)) #if 1 #define __Pyx_c_abs_double(z) (cabs(z)) #define __Pyx_c_pow_double(a, b) (cpow(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); #endif #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* FunctionImport.proto */ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'cpython.buffer' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdio' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.type' */ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; /* Module declarations from 'cpython' */ /* Module declarations from 'cpython.object' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'cpython.mem' */ /* Module declarations from 'numpy' */ /* Module declarations from 'numpy' */ static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ /* Module declarations from 'regions._geometry.core' */ static double (*__pyx_f_7regions_9_geometry_4core_area_arc)(double, double, double, double, double); /*proto*/ static double (*__pyx_f_7regions_9_geometry_4core_area_triangle)(double, double, double, double, double, double); /*proto*/ static double (*__pyx_f_7regions_9_geometry_4core_floor_sqrt)(double); /*proto*/ /* Module declarations from 'regions._geometry.circular_overlap' */ static double __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_subpixel(double, double, double, double, double, int); /*proto*/ static double __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(double, double, double, double, double); /*proto*/ static double __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_core(double, double, double, double, double); /*proto*/ static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_16circular_overlap_DTYPE_t = { "DTYPE_t", NULL, sizeof(__pyx_t_7regions_9_geometry_16circular_overlap_DTYPE_t), { 0 }, 0, 'R', 0, 0 }; #define __Pyx_MODULE_NAME "regions._geometry.circular_overlap" extern int __pyx_module_is_main_regions___geometry__circular_overlap; int __pyx_module_is_main_regions___geometry__circular_overlap = 0; /* Implementation of 'regions._geometry.circular_overlap' */ static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_ImportError; static const char __pyx_k_d[] = "d"; static const char __pyx_k_i[] = "i"; static const char __pyx_k_j[] = "j"; static const char __pyx_k_r[] = "r"; static const char __pyx_k_x[] = "x"; static const char __pyx_k_y[] = "y"; static const char __pyx_k_dx[] = "dx"; static const char __pyx_k_dy[] = "dy"; static const char __pyx_k_np[] = "np"; static const char __pyx_k_nx[] = "nx"; static const char __pyx_k_ny[] = "ny"; static const char __pyx_k_all[] = "__all__"; static const char __pyx_k_frac[] = "frac"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_xmax[] = "xmax"; static const char __pyx_k_xmin[] = "xmin"; static const char __pyx_k_ymax[] = "ymax"; static const char __pyx_k_ymin[] = "ymin"; static const char __pyx_k_DTYPE[] = "DTYPE"; static const char __pyx_k_bxmax[] = "bxmax"; static const char __pyx_k_bxmin[] = "bxmin"; static const char __pyx_k_bymax[] = "bymax"; static const char __pyx_k_bymin[] = "bymin"; static const char __pyx_k_dtype[] = "dtype"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_pxcen[] = "pxcen"; static const char __pyx_k_pxmax[] = "pxmax"; static const char __pyx_k_pxmin[] = "pxmin"; static const char __pyx_k_pycen[] = "pycen"; static const char __pyx_k_pymax[] = "pymax"; static const char __pyx_k_pymin[] = "pymin"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_zeros[] = "zeros"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_float64[] = "float64"; static const char __pyx_k_subpixels[] = "subpixels"; static const char __pyx_k_use_exact[] = "use_exact"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_RuntimeError[] = "RuntimeError"; static const char __pyx_k_pixel_radius[] = "pixel_radius"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_circular_overlap_grid[] = "circular_overlap_grid"; static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; static const char __pyx_k_The_functions_defined_here_allo[] = "\nThe functions defined here allow one to determine the exact area of\noverlap of a rectangle and a circle (written by Thomas Robitaille).\n"; static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; static const char __pyx_k_regions__geometry_circular_overl[] = "regions/_geometry/circular_overlap.pyx"; static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; static const char __pyx_k_regions__geometry_circular_overl_2[] = "regions._geometry.circular_overlap"; static PyObject *__pyx_n_s_DTYPE; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; static PyObject *__pyx_n_s_RuntimeError; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_all; static PyObject *__pyx_n_s_bxmax; static PyObject *__pyx_n_s_bxmin; static PyObject *__pyx_n_s_bymax; static PyObject *__pyx_n_s_bymin; static PyObject *__pyx_n_s_circular_overlap_grid; static PyObject *__pyx_n_u_circular_overlap_grid; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_d; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_dx; static PyObject *__pyx_n_s_dy; static PyObject *__pyx_n_s_float64; static PyObject *__pyx_n_s_frac; static PyObject *__pyx_n_s_i; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_j; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_name; static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; static PyObject *__pyx_n_s_nx; static PyObject *__pyx_n_s_ny; static PyObject *__pyx_n_s_pixel_radius; static PyObject *__pyx_n_s_pxcen; static PyObject *__pyx_n_s_pxmax; static PyObject *__pyx_n_s_pxmin; static PyObject *__pyx_n_s_pycen; static PyObject *__pyx_n_s_pymax; static PyObject *__pyx_n_s_pymin; static PyObject *__pyx_n_s_r; static PyObject *__pyx_n_s_range; static PyObject *__pyx_kp_s_regions__geometry_circular_overl; static PyObject *__pyx_n_s_regions__geometry_circular_overl_2; static PyObject *__pyx_n_s_subpixels; static PyObject *__pyx_n_s_test; static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; static PyObject *__pyx_n_s_use_exact; static PyObject *__pyx_n_s_x; static PyObject *__pyx_n_s_xmax; static PyObject *__pyx_n_s_xmin; static PyObject *__pyx_n_s_y; static PyObject *__pyx_n_s_ymax; static PyObject *__pyx_n_s_ymin; static PyObject *__pyx_n_s_zeros; static PyObject *__pyx_pf_7regions_9_geometry_16circular_overlap_circular_overlap_grid(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_xmin, double __pyx_v_xmax, double __pyx_v_ymin, double __pyx_v_ymax, int __pyx_v_nx, int __pyx_v_ny, double __pyx_v_r, int __pyx_v_use_exact, int __pyx_v_subpixels); /* proto */ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_codeobj__9; /* Late includes */ /* "regions/_geometry/circular_overlap.pyx":34 * * * def circular_overlap_grid(double xmin, double xmax, double ymin, double ymax, # <<<<<<<<<<<<<< * int nx, int ny, double r, int use_exact, * int subpixels): */ /* Python wrapper */ static PyObject *__pyx_pw_7regions_9_geometry_16circular_overlap_1circular_overlap_grid(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7regions_9_geometry_16circular_overlap_circular_overlap_grid[] = "\n circular_overlap_grid(xmin, xmax, ymin, ymax, nx, ny, r,\n use_exact, subpixels)\n\n Area of overlap between a circle and a pixel grid. The circle is centered\n on the origin.\n\n Parameters\n ----------\n xmin, xmax, ymin, ymax : float\n Extent of the grid in the x and y direction.\n nx, ny : int\n Grid dimensions.\n r : float\n The radius of the circle.\n use_exact : 0 or 1\n If ``1`` calculates exact overlap, if ``0`` uses ``subpixel`` number\n of subpixels to calculate the overlap.\n subpixels : int\n Each pixel resampled by this factor in each dimension, thus each\n pixel is divided into ``subpixels ** 2`` subpixels.\n\n Returns\n -------\n frac : `~numpy.ndarray` (float)\n 2-d array of shape (ny, nx) giving the fraction of the overlap.\n "; static PyMethodDef __pyx_mdef_7regions_9_geometry_16circular_overlap_1circular_overlap_grid = {"circular_overlap_grid", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7regions_9_geometry_16circular_overlap_1circular_overlap_grid, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7regions_9_geometry_16circular_overlap_circular_overlap_grid}; static PyObject *__pyx_pw_7regions_9_geometry_16circular_overlap_1circular_overlap_grid(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { double __pyx_v_xmin; double __pyx_v_xmax; double __pyx_v_ymin; double __pyx_v_ymax; int __pyx_v_nx; int __pyx_v_ny; double __pyx_v_r; int __pyx_v_use_exact; int __pyx_v_subpixels; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("circular_overlap_grid (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_xmin,&__pyx_n_s_xmax,&__pyx_n_s_ymin,&__pyx_n_s_ymax,&__pyx_n_s_nx,&__pyx_n_s_ny,&__pyx_n_s_r,&__pyx_n_s_use_exact,&__pyx_n_s_subpixels,0}; PyObject* values[9] = {0,0,0,0,0,0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); CYTHON_FALLTHROUGH; case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); CYTHON_FALLTHROUGH; case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); CYTHON_FALLTHROUGH; case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xmin)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xmax)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("circular_overlap_grid", 1, 9, 9, 1); __PYX_ERR(0, 34, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ymin)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("circular_overlap_grid", 1, 9, 9, 2); __PYX_ERR(0, 34, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ymax)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("circular_overlap_grid", 1, 9, 9, 3); __PYX_ERR(0, 34, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nx)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("circular_overlap_grid", 1, 9, 9, 4); __PYX_ERR(0, 34, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ny)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("circular_overlap_grid", 1, 9, 9, 5); __PYX_ERR(0, 34, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 6: if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_r)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("circular_overlap_grid", 1, 9, 9, 6); __PYX_ERR(0, 34, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 7: if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_use_exact)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("circular_overlap_grid", 1, 9, 9, 7); __PYX_ERR(0, 34, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 8: if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_subpixels)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("circular_overlap_grid", 1, 9, 9, 8); __PYX_ERR(0, 34, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "circular_overlap_grid") < 0)) __PYX_ERR(0, 34, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 9) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); values[4] = PyTuple_GET_ITEM(__pyx_args, 4); values[5] = PyTuple_GET_ITEM(__pyx_args, 5); values[6] = PyTuple_GET_ITEM(__pyx_args, 6); values[7] = PyTuple_GET_ITEM(__pyx_args, 7); values[8] = PyTuple_GET_ITEM(__pyx_args, 8); } __pyx_v_xmin = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_xmin == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 34, __pyx_L3_error) __pyx_v_xmax = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_xmax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 34, __pyx_L3_error) __pyx_v_ymin = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_ymin == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 34, __pyx_L3_error) __pyx_v_ymax = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_ymax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 34, __pyx_L3_error) __pyx_v_nx = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_nx == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 35, __pyx_L3_error) __pyx_v_ny = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_ny == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 35, __pyx_L3_error) __pyx_v_r = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_r == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 35, __pyx_L3_error) __pyx_v_use_exact = __Pyx_PyInt_As_int(values[7]); if (unlikely((__pyx_v_use_exact == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 35, __pyx_L3_error) __pyx_v_subpixels = __Pyx_PyInt_As_int(values[8]); if (unlikely((__pyx_v_subpixels == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 36, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("circular_overlap_grid", 1, 9, 9, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 34, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("regions._geometry.circular_overlap.circular_overlap_grid", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7regions_9_geometry_16circular_overlap_circular_overlap_grid(__pyx_self, __pyx_v_xmin, __pyx_v_xmax, __pyx_v_ymin, __pyx_v_ymax, __pyx_v_nx, __pyx_v_ny, __pyx_v_r, __pyx_v_use_exact, __pyx_v_subpixels); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7regions_9_geometry_16circular_overlap_circular_overlap_grid(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_xmin, double __pyx_v_xmax, double __pyx_v_ymin, double __pyx_v_ymax, int __pyx_v_nx, int __pyx_v_ny, double __pyx_v_r, int __pyx_v_use_exact, int __pyx_v_subpixels) { unsigned int __pyx_v_i; unsigned int __pyx_v_j; double __pyx_v_dx; double __pyx_v_dy; double __pyx_v_d; double __pyx_v_pixel_radius; double __pyx_v_bxmin; double __pyx_v_bxmax; double __pyx_v_bymin; double __pyx_v_bymax; double __pyx_v_pxmin; double __pyx_v_pxcen; double __pyx_v_pxmax; double __pyx_v_pymin; double __pyx_v_pycen; double __pyx_v_pymax; PyArrayObject *__pyx_v_frac = 0; __Pyx_LocalBuf_ND __pyx_pybuffernd_frac; __Pyx_Buffer __pyx_pybuffer_frac; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyArrayObject *__pyx_t_5 = NULL; double __pyx_t_6; int __pyx_t_7; int __pyx_t_8; unsigned int __pyx_t_9; int __pyx_t_10; int __pyx_t_11; int __pyx_t_12; int __pyx_t_13; unsigned int __pyx_t_14; size_t __pyx_t_15; size_t __pyx_t_16; int __pyx_t_17; double __pyx_t_18; size_t __pyx_t_19; size_t __pyx_t_20; size_t __pyx_t_21; size_t __pyx_t_22; __Pyx_RefNannySetupContext("circular_overlap_grid", 0); __pyx_pybuffer_frac.pybuffer.buf = NULL; __pyx_pybuffer_frac.refcount = 0; __pyx_pybuffernd_frac.data = NULL; __pyx_pybuffernd_frac.rcbuffer = &__pyx_pybuffer_frac; /* "regions/_geometry/circular_overlap.pyx":71 * * # Define output array * cdef np.ndarray[DTYPE_t, ndim=2] frac = np.zeros([ny, nx], dtype=DTYPE) # <<<<<<<<<<<<<< * * # Find the width of each element in x and y */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_ny); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_nx); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_3); PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 71, __pyx_L1_error) __pyx_t_5 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_frac.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_16circular_overlap_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) { __pyx_v_frac = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_frac.rcbuffer->pybuffer.buf = NULL; __PYX_ERR(0, 71, __pyx_L1_error) } else {__pyx_pybuffernd_frac.diminfo[0].strides = __pyx_pybuffernd_frac.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_frac.diminfo[0].shape = __pyx_pybuffernd_frac.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_frac.diminfo[1].strides = __pyx_pybuffernd_frac.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_frac.diminfo[1].shape = __pyx_pybuffernd_frac.rcbuffer->pybuffer.shape[1]; } } __pyx_t_5 = 0; __pyx_v_frac = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/circular_overlap.pyx":74 * * # Find the width of each element in x and y * dx = (xmax - xmin) / nx # <<<<<<<<<<<<<< * dy = (ymax - ymin) / ny * */ __pyx_t_6 = (__pyx_v_xmax - __pyx_v_xmin); if (unlikely(__pyx_v_nx == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 74, __pyx_L1_error) } __pyx_v_dx = (__pyx_t_6 / ((double)__pyx_v_nx)); /* "regions/_geometry/circular_overlap.pyx":75 * # Find the width of each element in x and y * dx = (xmax - xmin) / nx * dy = (ymax - ymin) / ny # <<<<<<<<<<<<<< * * # Find the radius of a single pixel */ __pyx_t_6 = (__pyx_v_ymax - __pyx_v_ymin); if (unlikely(__pyx_v_ny == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 75, __pyx_L1_error) } __pyx_v_dy = (__pyx_t_6 / ((double)__pyx_v_ny)); /* "regions/_geometry/circular_overlap.pyx":78 * * # Find the radius of a single pixel * pixel_radius = 0.5 * sqrt(dx * dx + dy * dy) # <<<<<<<<<<<<<< * * # Define bounding box */ __pyx_v_pixel_radius = (0.5 * sqrt(((__pyx_v_dx * __pyx_v_dx) + (__pyx_v_dy * __pyx_v_dy)))); /* "regions/_geometry/circular_overlap.pyx":81 * * # Define bounding box * bxmin = -r - 0.5 * dx # <<<<<<<<<<<<<< * bxmax = +r + 0.5 * dx * bymin = -r - 0.5 * dy */ __pyx_v_bxmin = ((-__pyx_v_r) - (0.5 * __pyx_v_dx)); /* "regions/_geometry/circular_overlap.pyx":82 * # Define bounding box * bxmin = -r - 0.5 * dx * bxmax = +r + 0.5 * dx # <<<<<<<<<<<<<< * bymin = -r - 0.5 * dy * bymax = +r + 0.5 * dy */ __pyx_v_bxmax = (__pyx_v_r + (0.5 * __pyx_v_dx)); /* "regions/_geometry/circular_overlap.pyx":83 * bxmin = -r - 0.5 * dx * bxmax = +r + 0.5 * dx * bymin = -r - 0.5 * dy # <<<<<<<<<<<<<< * bymax = +r + 0.5 * dy * */ __pyx_v_bymin = ((-__pyx_v_r) - (0.5 * __pyx_v_dy)); /* "regions/_geometry/circular_overlap.pyx":84 * bxmax = +r + 0.5 * dx * bymin = -r - 0.5 * dy * bymax = +r + 0.5 * dy # <<<<<<<<<<<<<< * * for i in range(nx): */ __pyx_v_bymax = (__pyx_v_r + (0.5 * __pyx_v_dy)); /* "regions/_geometry/circular_overlap.pyx":86 * bymax = +r + 0.5 * dy * * for i in range(nx): # <<<<<<<<<<<<<< * pxmin = xmin + i * dx # lower end of pixel * pxcen = pxmin + dx * 0.5 */ __pyx_t_7 = __pyx_v_nx; __pyx_t_8 = __pyx_t_7; for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) { __pyx_v_i = __pyx_t_9; /* "regions/_geometry/circular_overlap.pyx":87 * * for i in range(nx): * pxmin = xmin + i * dx # lower end of pixel # <<<<<<<<<<<<<< * pxcen = pxmin + dx * 0.5 * pxmax = pxmin + dx # upper end of pixel */ __pyx_v_pxmin = (__pyx_v_xmin + (__pyx_v_i * __pyx_v_dx)); /* "regions/_geometry/circular_overlap.pyx":88 * for i in range(nx): * pxmin = xmin + i * dx # lower end of pixel * pxcen = pxmin + dx * 0.5 # <<<<<<<<<<<<<< * pxmax = pxmin + dx # upper end of pixel * if pxmax > bxmin and pxmin < bxmax: */ __pyx_v_pxcen = (__pyx_v_pxmin + (__pyx_v_dx * 0.5)); /* "regions/_geometry/circular_overlap.pyx":89 * pxmin = xmin + i * dx # lower end of pixel * pxcen = pxmin + dx * 0.5 * pxmax = pxmin + dx # upper end of pixel # <<<<<<<<<<<<<< * if pxmax > bxmin and pxmin < bxmax: * for j in range(ny): */ __pyx_v_pxmax = (__pyx_v_pxmin + __pyx_v_dx); /* "regions/_geometry/circular_overlap.pyx":90 * pxcen = pxmin + dx * 0.5 * pxmax = pxmin + dx # upper end of pixel * if pxmax > bxmin and pxmin < bxmax: # <<<<<<<<<<<<<< * for j in range(ny): * pymin = ymin + j * dy */ __pyx_t_11 = ((__pyx_v_pxmax > __pyx_v_bxmin) != 0); if (__pyx_t_11) { } else { __pyx_t_10 = __pyx_t_11; goto __pyx_L6_bool_binop_done; } __pyx_t_11 = ((__pyx_v_pxmin < __pyx_v_bxmax) != 0); __pyx_t_10 = __pyx_t_11; __pyx_L6_bool_binop_done:; if (__pyx_t_10) { /* "regions/_geometry/circular_overlap.pyx":91 * pxmax = pxmin + dx # upper end of pixel * if pxmax > bxmin and pxmin < bxmax: * for j in range(ny): # <<<<<<<<<<<<<< * pymin = ymin + j * dy * pycen = pymin + dy * 0.5 */ __pyx_t_12 = __pyx_v_ny; __pyx_t_13 = __pyx_t_12; for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { __pyx_v_j = __pyx_t_14; /* "regions/_geometry/circular_overlap.pyx":92 * if pxmax > bxmin and pxmin < bxmax: * for j in range(ny): * pymin = ymin + j * dy # <<<<<<<<<<<<<< * pycen = pymin + dy * 0.5 * pymax = pymin + dy */ __pyx_v_pymin = (__pyx_v_ymin + (__pyx_v_j * __pyx_v_dy)); /* "regions/_geometry/circular_overlap.pyx":93 * for j in range(ny): * pymin = ymin + j * dy * pycen = pymin + dy * 0.5 # <<<<<<<<<<<<<< * pymax = pymin + dy * if pymax > bymin and pymin < bymax: */ __pyx_v_pycen = (__pyx_v_pymin + (__pyx_v_dy * 0.5)); /* "regions/_geometry/circular_overlap.pyx":94 * pymin = ymin + j * dy * pycen = pymin + dy * 0.5 * pymax = pymin + dy # <<<<<<<<<<<<<< * if pymax > bymin and pymin < bymax: * */ __pyx_v_pymax = (__pyx_v_pymin + __pyx_v_dy); /* "regions/_geometry/circular_overlap.pyx":95 * pycen = pymin + dy * 0.5 * pymax = pymin + dy * if pymax > bymin and pymin < bymax: # <<<<<<<<<<<<<< * * # Distance from circle center to pixel center. */ __pyx_t_11 = ((__pyx_v_pymax > __pyx_v_bymin) != 0); if (__pyx_t_11) { } else { __pyx_t_10 = __pyx_t_11; goto __pyx_L11_bool_binop_done; } __pyx_t_11 = ((__pyx_v_pymin < __pyx_v_bymax) != 0); __pyx_t_10 = __pyx_t_11; __pyx_L11_bool_binop_done:; if (__pyx_t_10) { /* "regions/_geometry/circular_overlap.pyx":98 * * # Distance from circle center to pixel center. * d = sqrt(pxcen * pxcen + pycen * pycen) # <<<<<<<<<<<<<< * * # If pixel center is "well within" circle, count full */ __pyx_v_d = sqrt(((__pyx_v_pxcen * __pyx_v_pxcen) + (__pyx_v_pycen * __pyx_v_pycen))); /* "regions/_geometry/circular_overlap.pyx":102 * # If pixel center is "well within" circle, count full * # pixel. * if d < r - pixel_radius: # <<<<<<<<<<<<<< * frac[j, i] = 1. * */ __pyx_t_10 = ((__pyx_v_d < (__pyx_v_r - __pyx_v_pixel_radius)) != 0); if (__pyx_t_10) { /* "regions/_geometry/circular_overlap.pyx":103 * # pixel. * if d < r - pixel_radius: * frac[j, i] = 1. # <<<<<<<<<<<<<< * * # If pixel center is "close" to circle border, find */ __pyx_t_15 = __pyx_v_j; __pyx_t_16 = __pyx_v_i; __pyx_t_17 = -1; if (unlikely(__pyx_t_15 >= (size_t)__pyx_pybuffernd_frac.diminfo[0].shape)) __pyx_t_17 = 0; if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_frac.diminfo[1].shape)) __pyx_t_17 = 1; if (unlikely(__pyx_t_17 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_17); __PYX_ERR(0, 103, __pyx_L1_error) } *__Pyx_BufPtrStrided2d(__pyx_t_7regions_9_geometry_16circular_overlap_DTYPE_t *, __pyx_pybuffernd_frac.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_frac.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_frac.diminfo[1].strides) = 1.; /* "regions/_geometry/circular_overlap.pyx":102 * # If pixel center is "well within" circle, count full * # pixel. * if d < r - pixel_radius: # <<<<<<<<<<<<<< * frac[j, i] = 1. * */ goto __pyx_L13; } /* "regions/_geometry/circular_overlap.pyx":107 * # If pixel center is "close" to circle border, find * # overlap. * elif d < r + pixel_radius: # <<<<<<<<<<<<<< * * # Either do exact calculation or use subpixel */ __pyx_t_10 = ((__pyx_v_d < (__pyx_v_r + __pyx_v_pixel_radius)) != 0); if (__pyx_t_10) { /* "regions/_geometry/circular_overlap.pyx":111 * # Either do exact calculation or use subpixel * # sampling: * if use_exact: # <<<<<<<<<<<<<< * frac[j, i] = circular_overlap_single_exact( * pxmin, pymin, pxmax, pymax, r) / (dx * dy) */ __pyx_t_10 = (__pyx_v_use_exact != 0); if (__pyx_t_10) { /* "regions/_geometry/circular_overlap.pyx":112 * # sampling: * if use_exact: * frac[j, i] = circular_overlap_single_exact( # <<<<<<<<<<<<<< * pxmin, pymin, pxmax, pymax, r) / (dx * dy) * else: */ __pyx_t_6 = __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(__pyx_v_pxmin, __pyx_v_pymin, __pyx_v_pxmax, __pyx_v_pymax, __pyx_v_r); /* "regions/_geometry/circular_overlap.pyx":113 * if use_exact: * frac[j, i] = circular_overlap_single_exact( * pxmin, pymin, pxmax, pymax, r) / (dx * dy) # <<<<<<<<<<<<<< * else: * frac[j, i] = circular_overlap_single_subpixel( */ __pyx_t_18 = (__pyx_v_dx * __pyx_v_dy); if (unlikely(__pyx_t_18 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 113, __pyx_L1_error) } /* "regions/_geometry/circular_overlap.pyx":112 * # sampling: * if use_exact: * frac[j, i] = circular_overlap_single_exact( # <<<<<<<<<<<<<< * pxmin, pymin, pxmax, pymax, r) / (dx * dy) * else: */ __pyx_t_19 = __pyx_v_j; __pyx_t_20 = __pyx_v_i; __pyx_t_17 = -1; if (unlikely(__pyx_t_19 >= (size_t)__pyx_pybuffernd_frac.diminfo[0].shape)) __pyx_t_17 = 0; if (unlikely(__pyx_t_20 >= (size_t)__pyx_pybuffernd_frac.diminfo[1].shape)) __pyx_t_17 = 1; if (unlikely(__pyx_t_17 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_17); __PYX_ERR(0, 112, __pyx_L1_error) } *__Pyx_BufPtrStrided2d(__pyx_t_7regions_9_geometry_16circular_overlap_DTYPE_t *, __pyx_pybuffernd_frac.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_frac.diminfo[0].strides, __pyx_t_20, __pyx_pybuffernd_frac.diminfo[1].strides) = (__pyx_t_6 / __pyx_t_18); /* "regions/_geometry/circular_overlap.pyx":111 * # Either do exact calculation or use subpixel * # sampling: * if use_exact: # <<<<<<<<<<<<<< * frac[j, i] = circular_overlap_single_exact( * pxmin, pymin, pxmax, pymax, r) / (dx * dy) */ goto __pyx_L14; } /* "regions/_geometry/circular_overlap.pyx":115 * pxmin, pymin, pxmax, pymax, r) / (dx * dy) * else: * frac[j, i] = circular_overlap_single_subpixel( # <<<<<<<<<<<<<< * pxmin, pymin, pxmax, pymax, r, subpixels) * */ /*else*/ { /* "regions/_geometry/circular_overlap.pyx":116 * else: * frac[j, i] = circular_overlap_single_subpixel( * pxmin, pymin, pxmax, pymax, r, subpixels) # <<<<<<<<<<<<<< * * # Otherwise, it is fully outside circle. */ __pyx_t_21 = __pyx_v_j; __pyx_t_22 = __pyx_v_i; __pyx_t_17 = -1; if (unlikely(__pyx_t_21 >= (size_t)__pyx_pybuffernd_frac.diminfo[0].shape)) __pyx_t_17 = 0; if (unlikely(__pyx_t_22 >= (size_t)__pyx_pybuffernd_frac.diminfo[1].shape)) __pyx_t_17 = 1; if (unlikely(__pyx_t_17 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_17); __PYX_ERR(0, 115, __pyx_L1_error) } *__Pyx_BufPtrStrided2d(__pyx_t_7regions_9_geometry_16circular_overlap_DTYPE_t *, __pyx_pybuffernd_frac.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_frac.diminfo[0].strides, __pyx_t_22, __pyx_pybuffernd_frac.diminfo[1].strides) = __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_subpixel(__pyx_v_pxmin, __pyx_v_pymin, __pyx_v_pxmax, __pyx_v_pymax, __pyx_v_r, __pyx_v_subpixels); } __pyx_L14:; /* "regions/_geometry/circular_overlap.pyx":107 * # If pixel center is "close" to circle border, find * # overlap. * elif d < r + pixel_radius: # <<<<<<<<<<<<<< * * # Either do exact calculation or use subpixel */ } __pyx_L13:; /* "regions/_geometry/circular_overlap.pyx":95 * pycen = pymin + dy * 0.5 * pymax = pymin + dy * if pymax > bymin and pymin < bymax: # <<<<<<<<<<<<<< * * # Distance from circle center to pixel center. */ } } /* "regions/_geometry/circular_overlap.pyx":90 * pxcen = pxmin + dx * 0.5 * pxmax = pxmin + dx # upper end of pixel * if pxmax > bxmin and pxmin < bxmax: # <<<<<<<<<<<<<< * for j in range(ny): * pymin = ymin + j * dy */ } } /* "regions/_geometry/circular_overlap.pyx":121 * # No action needed. * * return frac # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_frac)); __pyx_r = ((PyObject *)__pyx_v_frac); goto __pyx_L0; /* "regions/_geometry/circular_overlap.pyx":34 * * * def circular_overlap_grid(double xmin, double xmax, double ymin, double ymax, # <<<<<<<<<<<<<< * int nx, int ny, double r, int use_exact, * int subpixels): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_frac.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("regions._geometry.circular_overlap.circular_overlap_grid", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_frac.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_frac); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/circular_overlap.pyx":130 * * * cdef double circular_overlap_single_subpixel(double x0, double y0, # <<<<<<<<<<<<<< * double x1, double y1, * double r, int subpixels): */ static double __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_subpixel(double __pyx_v_x0, double __pyx_v_y0, double __pyx_v_x1, double __pyx_v_y1, double __pyx_v_r, int __pyx_v_subpixels) { CYTHON_UNUSED unsigned int __pyx_v_i; CYTHON_UNUSED unsigned int __pyx_v_j; double __pyx_v_x; double __pyx_v_y; double __pyx_v_dx; double __pyx_v_dy; double __pyx_v_r_squared; double __pyx_v_frac; double __pyx_r; __Pyx_RefNannyDeclarations double __pyx_t_1; int __pyx_t_2; int __pyx_t_3; unsigned int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; unsigned int __pyx_t_7; int __pyx_t_8; __Pyx_RefNannySetupContext("circular_overlap_single_subpixel", 0); /* "regions/_geometry/circular_overlap.pyx":138 * cdef unsigned int i, j * cdef double x, y, dx, dy, r_squared * cdef double frac = 0. # Accumulator. # <<<<<<<<<<<<<< * * dx = (x1 - x0) / subpixels */ __pyx_v_frac = 0.; /* "regions/_geometry/circular_overlap.pyx":140 * cdef double frac = 0. # Accumulator. * * dx = (x1 - x0) / subpixels # <<<<<<<<<<<<<< * dy = (y1 - y0) / subpixels * r_squared = r ** 2 */ __pyx_t_1 = (__pyx_v_x1 - __pyx_v_x0); if (unlikely(__pyx_v_subpixels == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 140, __pyx_L1_error) } __pyx_v_dx = (__pyx_t_1 / ((double)__pyx_v_subpixels)); /* "regions/_geometry/circular_overlap.pyx":141 * * dx = (x1 - x0) / subpixels * dy = (y1 - y0) / subpixels # <<<<<<<<<<<<<< * r_squared = r ** 2 * */ __pyx_t_1 = (__pyx_v_y1 - __pyx_v_y0); if (unlikely(__pyx_v_subpixels == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 141, __pyx_L1_error) } __pyx_v_dy = (__pyx_t_1 / ((double)__pyx_v_subpixels)); /* "regions/_geometry/circular_overlap.pyx":142 * dx = (x1 - x0) / subpixels * dy = (y1 - y0) / subpixels * r_squared = r ** 2 # <<<<<<<<<<<<<< * * x = x0 - 0.5 * dx */ __pyx_v_r_squared = pow(__pyx_v_r, 2.0); /* "regions/_geometry/circular_overlap.pyx":144 * r_squared = r ** 2 * * x = x0 - 0.5 * dx # <<<<<<<<<<<<<< * for i in range(subpixels): * x += dx */ __pyx_v_x = (__pyx_v_x0 - (0.5 * __pyx_v_dx)); /* "regions/_geometry/circular_overlap.pyx":145 * * x = x0 - 0.5 * dx * for i in range(subpixels): # <<<<<<<<<<<<<< * x += dx * y = y0 - 0.5 * dy */ __pyx_t_2 = __pyx_v_subpixels; __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; /* "regions/_geometry/circular_overlap.pyx":146 * x = x0 - 0.5 * dx * for i in range(subpixels): * x += dx # <<<<<<<<<<<<<< * y = y0 - 0.5 * dy * for j in range(subpixels): */ __pyx_v_x = (__pyx_v_x + __pyx_v_dx); /* "regions/_geometry/circular_overlap.pyx":147 * for i in range(subpixels): * x += dx * y = y0 - 0.5 * dy # <<<<<<<<<<<<<< * for j in range(subpixels): * y += dy */ __pyx_v_y = (__pyx_v_y0 - (0.5 * __pyx_v_dy)); /* "regions/_geometry/circular_overlap.pyx":148 * x += dx * y = y0 - 0.5 * dy * for j in range(subpixels): # <<<<<<<<<<<<<< * y += dy * if x * x + y * y < r_squared: */ __pyx_t_5 = __pyx_v_subpixels; __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_j = __pyx_t_7; /* "regions/_geometry/circular_overlap.pyx":149 * y = y0 - 0.5 * dy * for j in range(subpixels): * y += dy # <<<<<<<<<<<<<< * if x * x + y * y < r_squared: * frac += 1. */ __pyx_v_y = (__pyx_v_y + __pyx_v_dy); /* "regions/_geometry/circular_overlap.pyx":150 * for j in range(subpixels): * y += dy * if x * x + y * y < r_squared: # <<<<<<<<<<<<<< * frac += 1. * */ __pyx_t_8 = ((((__pyx_v_x * __pyx_v_x) + (__pyx_v_y * __pyx_v_y)) < __pyx_v_r_squared) != 0); if (__pyx_t_8) { /* "regions/_geometry/circular_overlap.pyx":151 * y += dy * if x * x + y * y < r_squared: * frac += 1. # <<<<<<<<<<<<<< * * return frac / (subpixels * subpixels) */ __pyx_v_frac = (__pyx_v_frac + 1.); /* "regions/_geometry/circular_overlap.pyx":150 * for j in range(subpixels): * y += dy * if x * x + y * y < r_squared: # <<<<<<<<<<<<<< * frac += 1. * */ } } } /* "regions/_geometry/circular_overlap.pyx":153 * frac += 1. * * return frac / (subpixels * subpixels) # <<<<<<<<<<<<<< * * */ __pyx_t_2 = (__pyx_v_subpixels * __pyx_v_subpixels); if (unlikely(__pyx_t_2 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 153, __pyx_L1_error) } __pyx_r = (__pyx_v_frac / ((double)__pyx_t_2)); goto __pyx_L0; /* "regions/_geometry/circular_overlap.pyx":130 * * * cdef double circular_overlap_single_subpixel(double x0, double y0, # <<<<<<<<<<<<<< * double x1, double y1, * double r, int subpixels): */ /* function exit code */ __pyx_L1_error:; __Pyx_WriteUnraisable("regions._geometry.circular_overlap.circular_overlap_single_subpixel", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/circular_overlap.pyx":156 * * * cdef double circular_overlap_single_exact(double xmin, double ymin, # <<<<<<<<<<<<<< * double xmax, double ymax, * double r): */ static double __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(double __pyx_v_xmin, double __pyx_v_ymin, double __pyx_v_xmax, double __pyx_v_ymax, double __pyx_v_r) { double __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("circular_overlap_single_exact", 0); /* "regions/_geometry/circular_overlap.pyx":162 * Area of overlap of a rectangle and a circle * """ * if 0. <= xmin: # <<<<<<<<<<<<<< * if 0. <= ymin: * return circular_overlap_core(xmin, ymin, xmax, ymax, r) */ __pyx_t_1 = ((0. <= __pyx_v_xmin) != 0); if (__pyx_t_1) { /* "regions/_geometry/circular_overlap.pyx":163 * """ * if 0. <= xmin: * if 0. <= ymin: # <<<<<<<<<<<<<< * return circular_overlap_core(xmin, ymin, xmax, ymax, r) * elif 0. >= ymax: */ __pyx_t_1 = ((0. <= __pyx_v_ymin) != 0); if (__pyx_t_1) { /* "regions/_geometry/circular_overlap.pyx":164 * if 0. <= xmin: * if 0. <= ymin: * return circular_overlap_core(xmin, ymin, xmax, ymax, r) # <<<<<<<<<<<<<< * elif 0. >= ymax: * return circular_overlap_core(-ymax, xmin, -ymin, xmax, r) */ __pyx_r = __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_core(__pyx_v_xmin, __pyx_v_ymin, __pyx_v_xmax, __pyx_v_ymax, __pyx_v_r); goto __pyx_L0; /* "regions/_geometry/circular_overlap.pyx":163 * """ * if 0. <= xmin: * if 0. <= ymin: # <<<<<<<<<<<<<< * return circular_overlap_core(xmin, ymin, xmax, ymax, r) * elif 0. >= ymax: */ } /* "regions/_geometry/circular_overlap.pyx":165 * if 0. <= ymin: * return circular_overlap_core(xmin, ymin, xmax, ymax, r) * elif 0. >= ymax: # <<<<<<<<<<<<<< * return circular_overlap_core(-ymax, xmin, -ymin, xmax, r) * else: */ __pyx_t_1 = ((0. >= __pyx_v_ymax) != 0); if (__pyx_t_1) { /* "regions/_geometry/circular_overlap.pyx":166 * return circular_overlap_core(xmin, ymin, xmax, ymax, r) * elif 0. >= ymax: * return circular_overlap_core(-ymax, xmin, -ymin, xmax, r) # <<<<<<<<<<<<<< * else: * return circular_overlap_single_exact(xmin, ymin, xmax, 0., r) \ */ __pyx_r = __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_core((-__pyx_v_ymax), __pyx_v_xmin, (-__pyx_v_ymin), __pyx_v_xmax, __pyx_v_r); goto __pyx_L0; /* "regions/_geometry/circular_overlap.pyx":165 * if 0. <= ymin: * return circular_overlap_core(xmin, ymin, xmax, ymax, r) * elif 0. >= ymax: # <<<<<<<<<<<<<< * return circular_overlap_core(-ymax, xmin, -ymin, xmax, r) * else: */ } /* "regions/_geometry/circular_overlap.pyx":168 * return circular_overlap_core(-ymax, xmin, -ymin, xmax, r) * else: * return circular_overlap_single_exact(xmin, ymin, xmax, 0., r) \ # <<<<<<<<<<<<<< * + circular_overlap_single_exact(xmin, 0., xmax, ymax, r) * elif 0. >= xmax: */ /*else*/ { /* "regions/_geometry/circular_overlap.pyx":169 * else: * return circular_overlap_single_exact(xmin, ymin, xmax, 0., r) \ * + circular_overlap_single_exact(xmin, 0., xmax, ymax, r) # <<<<<<<<<<<<<< * elif 0. >= xmax: * if 0. <= ymin: */ __pyx_r = (__pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(__pyx_v_xmin, __pyx_v_ymin, __pyx_v_xmax, 0., __pyx_v_r) + __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(__pyx_v_xmin, 0., __pyx_v_xmax, __pyx_v_ymax, __pyx_v_r)); goto __pyx_L0; } /* "regions/_geometry/circular_overlap.pyx":162 * Area of overlap of a rectangle and a circle * """ * if 0. <= xmin: # <<<<<<<<<<<<<< * if 0. <= ymin: * return circular_overlap_core(xmin, ymin, xmax, ymax, r) */ } /* "regions/_geometry/circular_overlap.pyx":170 * return circular_overlap_single_exact(xmin, ymin, xmax, 0., r) \ * + circular_overlap_single_exact(xmin, 0., xmax, ymax, r) * elif 0. >= xmax: # <<<<<<<<<<<<<< * if 0. <= ymin: * return circular_overlap_core(-xmax, ymin, -xmin, ymax, r) */ __pyx_t_1 = ((0. >= __pyx_v_xmax) != 0); if (__pyx_t_1) { /* "regions/_geometry/circular_overlap.pyx":171 * + circular_overlap_single_exact(xmin, 0., xmax, ymax, r) * elif 0. >= xmax: * if 0. <= ymin: # <<<<<<<<<<<<<< * return circular_overlap_core(-xmax, ymin, -xmin, ymax, r) * elif 0. >= ymax: */ __pyx_t_1 = ((0. <= __pyx_v_ymin) != 0); if (__pyx_t_1) { /* "regions/_geometry/circular_overlap.pyx":172 * elif 0. >= xmax: * if 0. <= ymin: * return circular_overlap_core(-xmax, ymin, -xmin, ymax, r) # <<<<<<<<<<<<<< * elif 0. >= ymax: * return circular_overlap_core(-xmax, -ymax, -xmin, -ymin, r) */ __pyx_r = __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_core((-__pyx_v_xmax), __pyx_v_ymin, (-__pyx_v_xmin), __pyx_v_ymax, __pyx_v_r); goto __pyx_L0; /* "regions/_geometry/circular_overlap.pyx":171 * + circular_overlap_single_exact(xmin, 0., xmax, ymax, r) * elif 0. >= xmax: * if 0. <= ymin: # <<<<<<<<<<<<<< * return circular_overlap_core(-xmax, ymin, -xmin, ymax, r) * elif 0. >= ymax: */ } /* "regions/_geometry/circular_overlap.pyx":173 * if 0. <= ymin: * return circular_overlap_core(-xmax, ymin, -xmin, ymax, r) * elif 0. >= ymax: # <<<<<<<<<<<<<< * return circular_overlap_core(-xmax, -ymax, -xmin, -ymin, r) * else: */ __pyx_t_1 = ((0. >= __pyx_v_ymax) != 0); if (__pyx_t_1) { /* "regions/_geometry/circular_overlap.pyx":174 * return circular_overlap_core(-xmax, ymin, -xmin, ymax, r) * elif 0. >= ymax: * return circular_overlap_core(-xmax, -ymax, -xmin, -ymin, r) # <<<<<<<<<<<<<< * else: * return circular_overlap_single_exact(xmin, ymin, xmax, 0., r) \ */ __pyx_r = __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_core((-__pyx_v_xmax), (-__pyx_v_ymax), (-__pyx_v_xmin), (-__pyx_v_ymin), __pyx_v_r); goto __pyx_L0; /* "regions/_geometry/circular_overlap.pyx":173 * if 0. <= ymin: * return circular_overlap_core(-xmax, ymin, -xmin, ymax, r) * elif 0. >= ymax: # <<<<<<<<<<<<<< * return circular_overlap_core(-xmax, -ymax, -xmin, -ymin, r) * else: */ } /* "regions/_geometry/circular_overlap.pyx":176 * return circular_overlap_core(-xmax, -ymax, -xmin, -ymin, r) * else: * return circular_overlap_single_exact(xmin, ymin, xmax, 0., r) \ # <<<<<<<<<<<<<< * + circular_overlap_single_exact(xmin, 0., xmax, ymax, r) * else: */ /*else*/ { /* "regions/_geometry/circular_overlap.pyx":177 * else: * return circular_overlap_single_exact(xmin, ymin, xmax, 0., r) \ * + circular_overlap_single_exact(xmin, 0., xmax, ymax, r) # <<<<<<<<<<<<<< * else: * if 0. <= ymin: */ __pyx_r = (__pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(__pyx_v_xmin, __pyx_v_ymin, __pyx_v_xmax, 0., __pyx_v_r) + __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(__pyx_v_xmin, 0., __pyx_v_xmax, __pyx_v_ymax, __pyx_v_r)); goto __pyx_L0; } /* "regions/_geometry/circular_overlap.pyx":170 * return circular_overlap_single_exact(xmin, ymin, xmax, 0., r) \ * + circular_overlap_single_exact(xmin, 0., xmax, ymax, r) * elif 0. >= xmax: # <<<<<<<<<<<<<< * if 0. <= ymin: * return circular_overlap_core(-xmax, ymin, -xmin, ymax, r) */ } /* "regions/_geometry/circular_overlap.pyx":179 * + circular_overlap_single_exact(xmin, 0., xmax, ymax, r) * else: * if 0. <= ymin: # <<<<<<<<<<<<<< * return circular_overlap_single_exact(xmin, ymin, 0., ymax, r) \ * + circular_overlap_single_exact(0., ymin, xmax, ymax, r) */ /*else*/ { __pyx_t_1 = ((0. <= __pyx_v_ymin) != 0); if (__pyx_t_1) { /* "regions/_geometry/circular_overlap.pyx":181 * if 0. <= ymin: * return circular_overlap_single_exact(xmin, ymin, 0., ymax, r) \ * + circular_overlap_single_exact(0., ymin, xmax, ymax, r) # <<<<<<<<<<<<<< * if 0. >= ymax: * return circular_overlap_single_exact(xmin, ymin, 0., ymax, r) \ */ __pyx_r = (__pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(__pyx_v_xmin, __pyx_v_ymin, 0., __pyx_v_ymax, __pyx_v_r) + __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(0., __pyx_v_ymin, __pyx_v_xmax, __pyx_v_ymax, __pyx_v_r)); goto __pyx_L0; /* "regions/_geometry/circular_overlap.pyx":179 * + circular_overlap_single_exact(xmin, 0., xmax, ymax, r) * else: * if 0. <= ymin: # <<<<<<<<<<<<<< * return circular_overlap_single_exact(xmin, ymin, 0., ymax, r) \ * + circular_overlap_single_exact(0., ymin, xmax, ymax, r) */ } /* "regions/_geometry/circular_overlap.pyx":182 * return circular_overlap_single_exact(xmin, ymin, 0., ymax, r) \ * + circular_overlap_single_exact(0., ymin, xmax, ymax, r) * if 0. >= ymax: # <<<<<<<<<<<<<< * return circular_overlap_single_exact(xmin, ymin, 0., ymax, r) \ * + circular_overlap_single_exact(0., ymin, xmax, ymax, r) */ __pyx_t_1 = ((0. >= __pyx_v_ymax) != 0); if (__pyx_t_1) { /* "regions/_geometry/circular_overlap.pyx":184 * if 0. >= ymax: * return circular_overlap_single_exact(xmin, ymin, 0., ymax, r) \ * + circular_overlap_single_exact(0., ymin, xmax, ymax, r) # <<<<<<<<<<<<<< * else: * return circular_overlap_single_exact(xmin, ymin, 0., 0., r) \ */ __pyx_r = (__pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(__pyx_v_xmin, __pyx_v_ymin, 0., __pyx_v_ymax, __pyx_v_r) + __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(0., __pyx_v_ymin, __pyx_v_xmax, __pyx_v_ymax, __pyx_v_r)); goto __pyx_L0; /* "regions/_geometry/circular_overlap.pyx":182 * return circular_overlap_single_exact(xmin, ymin, 0., ymax, r) \ * + circular_overlap_single_exact(0., ymin, xmax, ymax, r) * if 0. >= ymax: # <<<<<<<<<<<<<< * return circular_overlap_single_exact(xmin, ymin, 0., ymax, r) \ * + circular_overlap_single_exact(0., ymin, xmax, ymax, r) */ } /* "regions/_geometry/circular_overlap.pyx":186 * + circular_overlap_single_exact(0., ymin, xmax, ymax, r) * else: * return circular_overlap_single_exact(xmin, ymin, 0., 0., r) \ # <<<<<<<<<<<<<< * + circular_overlap_single_exact(0., ymin, xmax, 0., r) \ * + circular_overlap_single_exact(xmin, 0., 0., ymax, r) \ */ /*else*/ { /* "regions/_geometry/circular_overlap.pyx":189 * + circular_overlap_single_exact(0., ymin, xmax, 0., r) \ * + circular_overlap_single_exact(xmin, 0., 0., ymax, r) \ * + circular_overlap_single_exact(0., 0., xmax, ymax, r) # <<<<<<<<<<<<<< * * */ __pyx_r = (((__pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(__pyx_v_xmin, __pyx_v_ymin, 0., 0., __pyx_v_r) + __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(0., __pyx_v_ymin, __pyx_v_xmax, 0., __pyx_v_r)) + __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(__pyx_v_xmin, 0., 0., __pyx_v_ymax, __pyx_v_r)) + __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_single_exact(0., 0., __pyx_v_xmax, __pyx_v_ymax, __pyx_v_r)); goto __pyx_L0; } } /* "regions/_geometry/circular_overlap.pyx":156 * * * cdef double circular_overlap_single_exact(double xmin, double ymin, # <<<<<<<<<<<<<< * double xmax, double ymax, * double r): */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/circular_overlap.pyx":192 * * * cdef double circular_overlap_core(double xmin, double ymin, double xmax, double ymax, # <<<<<<<<<<<<<< * double r): * """ */ static double __pyx_f_7regions_9_geometry_16circular_overlap_circular_overlap_core(double __pyx_v_xmin, double __pyx_v_ymin, double __pyx_v_xmax, double __pyx_v_ymax, double __pyx_v_r) { double __pyx_v_area; double __pyx_v_d1; double __pyx_v_d2; double __pyx_v_x1; double __pyx_v_x2; double __pyx_v_y1; double __pyx_v_y2; double __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; double __pyx_t_3; double __pyx_t_4; __Pyx_RefNannySetupContext("circular_overlap_core", 0); /* "regions/_geometry/circular_overlap.pyx":201 * cdef double area, d1, d2, x1, x2, y1, y2 * * if xmin * xmin + ymin * ymin > r * r: # <<<<<<<<<<<<<< * area = 0. * elif xmax * xmax + ymax * ymax < r * r: */ __pyx_t_1 = ((((__pyx_v_xmin * __pyx_v_xmin) + (__pyx_v_ymin * __pyx_v_ymin)) > (__pyx_v_r * __pyx_v_r)) != 0); if (__pyx_t_1) { /* "regions/_geometry/circular_overlap.pyx":202 * * if xmin * xmin + ymin * ymin > r * r: * area = 0. # <<<<<<<<<<<<<< * elif xmax * xmax + ymax * ymax < r * r: * area = (xmax - xmin) * (ymax - ymin) */ __pyx_v_area = 0.; /* "regions/_geometry/circular_overlap.pyx":201 * cdef double area, d1, d2, x1, x2, y1, y2 * * if xmin * xmin + ymin * ymin > r * r: # <<<<<<<<<<<<<< * area = 0. * elif xmax * xmax + ymax * ymax < r * r: */ goto __pyx_L3; } /* "regions/_geometry/circular_overlap.pyx":203 * if xmin * xmin + ymin * ymin > r * r: * area = 0. * elif xmax * xmax + ymax * ymax < r * r: # <<<<<<<<<<<<<< * area = (xmax - xmin) * (ymax - ymin) * else: */ __pyx_t_1 = ((((__pyx_v_xmax * __pyx_v_xmax) + (__pyx_v_ymax * __pyx_v_ymax)) < (__pyx_v_r * __pyx_v_r)) != 0); if (__pyx_t_1) { /* "regions/_geometry/circular_overlap.pyx":204 * area = 0. * elif xmax * xmax + ymax * ymax < r * r: * area = (xmax - xmin) * (ymax - ymin) # <<<<<<<<<<<<<< * else: * area = 0. */ __pyx_v_area = ((__pyx_v_xmax - __pyx_v_xmin) * (__pyx_v_ymax - __pyx_v_ymin)); /* "regions/_geometry/circular_overlap.pyx":203 * if xmin * xmin + ymin * ymin > r * r: * area = 0. * elif xmax * xmax + ymax * ymax < r * r: # <<<<<<<<<<<<<< * area = (xmax - xmin) * (ymax - ymin) * else: */ goto __pyx_L3; } /* "regions/_geometry/circular_overlap.pyx":206 * area = (xmax - xmin) * (ymax - ymin) * else: * area = 0. # <<<<<<<<<<<<<< * d1 = floor_sqrt(xmax * xmax + ymin * ymin) * d2 = floor_sqrt(xmin * xmin + ymax * ymax) */ /*else*/ { __pyx_v_area = 0.; /* "regions/_geometry/circular_overlap.pyx":207 * else: * area = 0. * d1 = floor_sqrt(xmax * xmax + ymin * ymin) # <<<<<<<<<<<<<< * d2 = floor_sqrt(xmin * xmin + ymax * ymax) * if d1 < r and d2 < r: */ __pyx_v_d1 = __pyx_f_7regions_9_geometry_4core_floor_sqrt(((__pyx_v_xmax * __pyx_v_xmax) + (__pyx_v_ymin * __pyx_v_ymin))); /* "regions/_geometry/circular_overlap.pyx":208 * area = 0. * d1 = floor_sqrt(xmax * xmax + ymin * ymin) * d2 = floor_sqrt(xmin * xmin + ymax * ymax) # <<<<<<<<<<<<<< * if d1 < r and d2 < r: * x1, y1 = floor_sqrt(r * r - ymax * ymax), ymax */ __pyx_v_d2 = __pyx_f_7regions_9_geometry_4core_floor_sqrt(((__pyx_v_xmin * __pyx_v_xmin) + (__pyx_v_ymax * __pyx_v_ymax))); /* "regions/_geometry/circular_overlap.pyx":209 * d1 = floor_sqrt(xmax * xmax + ymin * ymin) * d2 = floor_sqrt(xmin * xmin + ymax * ymax) * if d1 < r and d2 < r: # <<<<<<<<<<<<<< * x1, y1 = floor_sqrt(r * r - ymax * ymax), ymax * x2, y2 = xmax, floor_sqrt(r * r - xmax * xmax) */ __pyx_t_2 = ((__pyx_v_d1 < __pyx_v_r) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L5_bool_binop_done; } __pyx_t_2 = ((__pyx_v_d2 < __pyx_v_r) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L5_bool_binop_done:; if (__pyx_t_1) { /* "regions/_geometry/circular_overlap.pyx":210 * d2 = floor_sqrt(xmin * xmin + ymax * ymax) * if d1 < r and d2 < r: * x1, y1 = floor_sqrt(r * r - ymax * ymax), ymax # <<<<<<<<<<<<<< * x2, y2 = xmax, floor_sqrt(r * r - xmax * xmax) * area = ((xmax - xmin) * (ymax - ymin) - */ __pyx_t_3 = __pyx_f_7regions_9_geometry_4core_floor_sqrt(((__pyx_v_r * __pyx_v_r) - (__pyx_v_ymax * __pyx_v_ymax))); __pyx_t_4 = __pyx_v_ymax; __pyx_v_x1 = __pyx_t_3; __pyx_v_y1 = __pyx_t_4; /* "regions/_geometry/circular_overlap.pyx":211 * if d1 < r and d2 < r: * x1, y1 = floor_sqrt(r * r - ymax * ymax), ymax * x2, y2 = xmax, floor_sqrt(r * r - xmax * xmax) # <<<<<<<<<<<<<< * area = ((xmax - xmin) * (ymax - ymin) - * area_triangle(x1, y1, x2, y2, xmax, ymax) + */ __pyx_t_4 = __pyx_v_xmax; __pyx_t_3 = __pyx_f_7regions_9_geometry_4core_floor_sqrt(((__pyx_v_r * __pyx_v_r) - (__pyx_v_xmax * __pyx_v_xmax))); __pyx_v_x2 = __pyx_t_4; __pyx_v_y2 = __pyx_t_3; /* "regions/_geometry/circular_overlap.pyx":213 * x2, y2 = xmax, floor_sqrt(r * r - xmax * xmax) * area = ((xmax - xmin) * (ymax - ymin) - * area_triangle(x1, y1, x2, y2, xmax, ymax) + # <<<<<<<<<<<<<< * area_arc(x1, y1, x2, y2, r)) * elif d1 < r: */ __pyx_v_area = ((((__pyx_v_xmax - __pyx_v_xmin) * (__pyx_v_ymax - __pyx_v_ymin)) - __pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2, __pyx_v_xmax, __pyx_v_ymax)) + __pyx_f_7regions_9_geometry_4core_area_arc(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2, __pyx_v_r)); /* "regions/_geometry/circular_overlap.pyx":209 * d1 = floor_sqrt(xmax * xmax + ymin * ymin) * d2 = floor_sqrt(xmin * xmin + ymax * ymax) * if d1 < r and d2 < r: # <<<<<<<<<<<<<< * x1, y1 = floor_sqrt(r * r - ymax * ymax), ymax * x2, y2 = xmax, floor_sqrt(r * r - xmax * xmax) */ goto __pyx_L4; } /* "regions/_geometry/circular_overlap.pyx":215 * area_triangle(x1, y1, x2, y2, xmax, ymax) + * area_arc(x1, y1, x2, y2, r)) * elif d1 < r: # <<<<<<<<<<<<<< * x1, y1 = xmin, floor_sqrt(r * r - xmin * xmin) * x2, y2 = xmax, floor_sqrt(r * r - xmax * xmax) */ __pyx_t_1 = ((__pyx_v_d1 < __pyx_v_r) != 0); if (__pyx_t_1) { /* "regions/_geometry/circular_overlap.pyx":216 * area_arc(x1, y1, x2, y2, r)) * elif d1 < r: * x1, y1 = xmin, floor_sqrt(r * r - xmin * xmin) # <<<<<<<<<<<<<< * x2, y2 = xmax, floor_sqrt(r * r - xmax * xmax) * area = (area_arc(x1, y1, x2, y2, r) + */ __pyx_t_3 = __pyx_v_xmin; __pyx_t_4 = __pyx_f_7regions_9_geometry_4core_floor_sqrt(((__pyx_v_r * __pyx_v_r) - (__pyx_v_xmin * __pyx_v_xmin))); __pyx_v_x1 = __pyx_t_3; __pyx_v_y1 = __pyx_t_4; /* "regions/_geometry/circular_overlap.pyx":217 * elif d1 < r: * x1, y1 = xmin, floor_sqrt(r * r - xmin * xmin) * x2, y2 = xmax, floor_sqrt(r * r - xmax * xmax) # <<<<<<<<<<<<<< * area = (area_arc(x1, y1, x2, y2, r) + * area_triangle(x1, y1, x1, ymin, xmax, ymin) + */ __pyx_t_4 = __pyx_v_xmax; __pyx_t_3 = __pyx_f_7regions_9_geometry_4core_floor_sqrt(((__pyx_v_r * __pyx_v_r) - (__pyx_v_xmax * __pyx_v_xmax))); __pyx_v_x2 = __pyx_t_4; __pyx_v_y2 = __pyx_t_3; /* "regions/_geometry/circular_overlap.pyx":219 * x2, y2 = xmax, floor_sqrt(r * r - xmax * xmax) * area = (area_arc(x1, y1, x2, y2, r) + * area_triangle(x1, y1, x1, ymin, xmax, ymin) + # <<<<<<<<<<<<<< * area_triangle(x1, y1, x2, ymin, x2, y2)) * elif d2 < r: */ __pyx_v_area = ((__pyx_f_7regions_9_geometry_4core_area_arc(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2, __pyx_v_r) + __pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_x1, __pyx_v_ymin, __pyx_v_xmax, __pyx_v_ymin)) + __pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_ymin, __pyx_v_x2, __pyx_v_y2)); /* "regions/_geometry/circular_overlap.pyx":215 * area_triangle(x1, y1, x2, y2, xmax, ymax) + * area_arc(x1, y1, x2, y2, r)) * elif d1 < r: # <<<<<<<<<<<<<< * x1, y1 = xmin, floor_sqrt(r * r - xmin * xmin) * x2, y2 = xmax, floor_sqrt(r * r - xmax * xmax) */ goto __pyx_L4; } /* "regions/_geometry/circular_overlap.pyx":221 * area_triangle(x1, y1, x1, ymin, xmax, ymin) + * area_triangle(x1, y1, x2, ymin, x2, y2)) * elif d2 < r: # <<<<<<<<<<<<<< * x1, y1 = floor_sqrt(r * r - ymin * ymin), ymin * x2, y2 = floor_sqrt(r * r - ymax * ymax), ymax */ __pyx_t_1 = ((__pyx_v_d2 < __pyx_v_r) != 0); if (__pyx_t_1) { /* "regions/_geometry/circular_overlap.pyx":222 * area_triangle(x1, y1, x2, ymin, x2, y2)) * elif d2 < r: * x1, y1 = floor_sqrt(r * r - ymin * ymin), ymin # <<<<<<<<<<<<<< * x2, y2 = floor_sqrt(r * r - ymax * ymax), ymax * area = (area_arc(x1, y1, x2, y2, r) + */ __pyx_t_3 = __pyx_f_7regions_9_geometry_4core_floor_sqrt(((__pyx_v_r * __pyx_v_r) - (__pyx_v_ymin * __pyx_v_ymin))); __pyx_t_4 = __pyx_v_ymin; __pyx_v_x1 = __pyx_t_3; __pyx_v_y1 = __pyx_t_4; /* "regions/_geometry/circular_overlap.pyx":223 * elif d2 < r: * x1, y1 = floor_sqrt(r * r - ymin * ymin), ymin * x2, y2 = floor_sqrt(r * r - ymax * ymax), ymax # <<<<<<<<<<<<<< * area = (area_arc(x1, y1, x2, y2, r) + * area_triangle(x1, y1, xmin, y1, xmin, ymax) + */ __pyx_t_4 = __pyx_f_7regions_9_geometry_4core_floor_sqrt(((__pyx_v_r * __pyx_v_r) - (__pyx_v_ymax * __pyx_v_ymax))); __pyx_t_3 = __pyx_v_ymax; __pyx_v_x2 = __pyx_t_4; __pyx_v_y2 = __pyx_t_3; /* "regions/_geometry/circular_overlap.pyx":225 * x2, y2 = floor_sqrt(r * r - ymax * ymax), ymax * area = (area_arc(x1, y1, x2, y2, r) + * area_triangle(x1, y1, xmin, y1, xmin, ymax) + # <<<<<<<<<<<<<< * area_triangle(x1, y1, xmin, y2, x2, y2)) * else: */ __pyx_v_area = ((__pyx_f_7regions_9_geometry_4core_area_arc(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2, __pyx_v_r) + __pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_xmin, __pyx_v_y1, __pyx_v_xmin, __pyx_v_ymax)) + __pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_xmin, __pyx_v_y2, __pyx_v_x2, __pyx_v_y2)); /* "regions/_geometry/circular_overlap.pyx":221 * area_triangle(x1, y1, x1, ymin, xmax, ymin) + * area_triangle(x1, y1, x2, ymin, x2, y2)) * elif d2 < r: # <<<<<<<<<<<<<< * x1, y1 = floor_sqrt(r * r - ymin * ymin), ymin * x2, y2 = floor_sqrt(r * r - ymax * ymax), ymax */ goto __pyx_L4; } /* "regions/_geometry/circular_overlap.pyx":228 * area_triangle(x1, y1, xmin, y2, x2, y2)) * else: * x1, y1 = floor_sqrt(r * r - ymin * ymin), ymin # <<<<<<<<<<<<<< * x2, y2 = xmin, floor_sqrt(r * r - xmin * xmin) * area = (area_arc(x1, y1, x2, y2, r) + */ /*else*/ { __pyx_t_3 = __pyx_f_7regions_9_geometry_4core_floor_sqrt(((__pyx_v_r * __pyx_v_r) - (__pyx_v_ymin * __pyx_v_ymin))); __pyx_t_4 = __pyx_v_ymin; __pyx_v_x1 = __pyx_t_3; __pyx_v_y1 = __pyx_t_4; /* "regions/_geometry/circular_overlap.pyx":229 * else: * x1, y1 = floor_sqrt(r * r - ymin * ymin), ymin * x2, y2 = xmin, floor_sqrt(r * r - xmin * xmin) # <<<<<<<<<<<<<< * area = (area_arc(x1, y1, x2, y2, r) + * area_triangle(x1, y1, x2, y2, xmin, ymin)) */ __pyx_t_4 = __pyx_v_xmin; __pyx_t_3 = __pyx_f_7regions_9_geometry_4core_floor_sqrt(((__pyx_v_r * __pyx_v_r) - (__pyx_v_xmin * __pyx_v_xmin))); __pyx_v_x2 = __pyx_t_4; __pyx_v_y2 = __pyx_t_3; /* "regions/_geometry/circular_overlap.pyx":230 * x1, y1 = floor_sqrt(r * r - ymin * ymin), ymin * x2, y2 = xmin, floor_sqrt(r * r - xmin * xmin) * area = (area_arc(x1, y1, x2, y2, r) + # <<<<<<<<<<<<<< * area_triangle(x1, y1, x2, y2, xmin, ymin)) * */ __pyx_v_area = (__pyx_f_7regions_9_geometry_4core_area_arc(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2, __pyx_v_r) + __pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2, __pyx_v_xmin, __pyx_v_ymin)); } __pyx_L4:; } __pyx_L3:; /* "regions/_geometry/circular_overlap.pyx":233 * area_triangle(x1, y1, x2, y2, xmin, ymin)) * * return area # <<<<<<<<<<<<<< */ __pyx_r = __pyx_v_area; goto __pyx_L0; /* "regions/_geometry/circular_overlap.pyx":192 * * * cdef double circular_overlap_core(double xmin, double ymin, double xmax, double ymax, # <<<<<<<<<<<<<< * double r): * """ */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< * # This implementation of getbuffer is geared towards Cython * # requirements, and does not yet fulfill the PEP. */ /* Python wrapper */ static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_v_i; int __pyx_v_ndim; int __pyx_v_endian_detector; int __pyx_v_little_endian; int __pyx_v_t; char *__pyx_v_f; PyArray_Descr *__pyx_v_descr = 0; int __pyx_v_offset; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyArray_Descr *__pyx_t_7; PyObject *__pyx_t_8 = NULL; char *__pyx_t_9; if (__pyx_v_info == NULL) { PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); return -1; } __Pyx_RefNannySetupContext("__getbuffer__", 0); __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 * * cdef int i, ndim * cdef int endian_detector = 1 # <<<<<<<<<<<<<< * cdef bint little_endian = ((&endian_detector)[0] != 0) * */ __pyx_v_endian_detector = 1; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 * cdef int i, ndim * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * * ndim = PyArray_NDIM(self) */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 * cdef bint little_endian = ((&endian_detector)[0] != 0) * * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) */ __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< * raise ValueError(u"ndarray is not C contiguous") * */ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 272, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L7_bool_binop_done; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< * raise ValueError(u"ndarray is not Fortran contiguous") * */ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L7_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 276, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 * raise ValueError(u"ndarray is not Fortran contiguous") * * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 * * info.buf = PyArray_DATA(self) * info.ndim = ndim # <<<<<<<<<<<<<< * if sizeof(npy_intp) != sizeof(Py_ssize_t): * # Allocate new buffer for strides and shape info. */ __pyx_v_info->ndim = __pyx_v_ndim; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. */ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< * info.shape = info.strides + ndim * for i in range(ndim): */ __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim # <<<<<<<<<<<<<< * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] */ __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim * for i in range(ndim): # <<<<<<<<<<<<<< * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] */ __pyx_t_4 = __pyx_v_ndim; __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286 * info.shape = info.strides + ndim * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< * info.shape[i] = PyArray_DIMS(self)[i] * else: */ (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287 * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< * else: * info.strides = PyArray_STRIDES(self) */ (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. */ goto __pyx_L9; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289 * info.shape[i] = PyArray_DIMS(self)[i] * else: * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL */ /*else*/ { __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 * else: * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) */ __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); } __pyx_L9:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL # <<<<<<<<<<<<<< * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) */ __pyx_v_info->suboffsets = NULL; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< * info.readonly = not PyArray_ISWRITEABLE(self) * */ __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< * * cdef int t */ __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296 * * cdef int t * cdef char* f = NULL # <<<<<<<<<<<<<< * cdef dtype descr = PyArray_DESCR(self) * cdef int offset */ __pyx_v_f = NULL; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297 * cdef int t * cdef char* f = NULL * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< * cdef int offset * */ __pyx_t_7 = PyArray_DESCR(__pyx_v_self); __pyx_t_3 = ((PyObject *)__pyx_t_7); __Pyx_INCREF(__pyx_t_3); __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300 * cdef int offset * * info.obj = self # <<<<<<<<<<<<<< * * if not PyDataType_HASFIELDS(descr): */ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or */ __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303 * * if not PyDataType_HASFIELDS(descr): * t = descr.type_num # <<<<<<<<<<<<<< * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): */ __pyx_t_4 = __pyx_v_descr->type_num; __pyx_v_t = __pyx_t_4; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); if (!__pyx_t_2) { goto __pyx_L15_next_or; } else { } __pyx_t_2 = (__pyx_v_little_endian != 0); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L14_bool_binop_done; } __pyx_L15_next_or:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305 * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" */ __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L14_bool_binop_done; } __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L14_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 306, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307 * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" */ switch (__pyx_v_t) { case NPY_BYTE: __pyx_v_f = ((char *)"b"); break; case NPY_UBYTE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308 * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" */ __pyx_v_f = ((char *)"B"); break; case NPY_SHORT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309 * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" */ __pyx_v_f = ((char *)"h"); break; case NPY_USHORT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310 * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" */ __pyx_v_f = ((char *)"H"); break; case NPY_INT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311 * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" */ __pyx_v_f = ((char *)"i"); break; case NPY_UINT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312 * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" */ __pyx_v_f = ((char *)"I"); break; case NPY_LONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313 * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" */ __pyx_v_f = ((char *)"l"); break; case NPY_ULONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314 * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" */ __pyx_v_f = ((char *)"L"); break; case NPY_LONGLONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315 * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" */ __pyx_v_f = ((char *)"q"); break; case NPY_ULONGLONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316 * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" */ __pyx_v_f = ((char *)"Q"); break; case NPY_FLOAT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317 * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" */ __pyx_v_f = ((char *)"f"); break; case NPY_DOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318 * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" */ __pyx_v_f = ((char *)"d"); break; case NPY_LONGDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319 * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" */ __pyx_v_f = ((char *)"g"); break; case NPY_CFLOAT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320 * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" */ __pyx_v_f = ((char *)"Zf"); break; case NPY_CDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321 * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" */ __pyx_v_f = ((char *)"Zd"); break; case NPY_CLONGDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322 * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f = "O" * else: */ __pyx_v_f = ((char *)"Zg"); break; case NPY_OBJECT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323 * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ __pyx_v_f = ((char *)"O"); break; default: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325 * elif t == NPY_OBJECT: f = "O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * info.format = f * return */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 325, __pyx_L1_error) break; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f # <<<<<<<<<<<<<< * return * else: */ __pyx_v_info->format = __pyx_v_f; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327 * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f * return # <<<<<<<<<<<<<< * else: * info.format = PyObject_Malloc(_buffer_format_string_len) */ __pyx_r = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329 * return * else: * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 */ /*else*/ { __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330 * else: * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< * offset = 0 * f = _util_dtypestring(descr, info.format + 1, */ (__pyx_v_info->format[0]) = '^'; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331 * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 # <<<<<<<<<<<<<< * f = _util_dtypestring(descr, info.format + 1, * info.format + _buffer_format_string_len, */ __pyx_v_offset = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332 * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< * info.format + _buffer_format_string_len, * &offset) */ __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error) __pyx_v_f = __pyx_t_9; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335 * info.format + _buffer_format_string_len, * &offset) * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< * * def __releasebuffer__(ndarray self, Py_buffer* info): */ (__pyx_v_f[0]) = '\x00'; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< * # This implementation of getbuffer is geared towards Cython * # requirements, and does not yet fulfill the PEP. */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; if (__pyx_v_info->obj != NULL) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } goto __pyx_L2; __pyx_L0:; if (__pyx_v_info->obj == Py_None) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_descr); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) */ /* Python wrapper */ static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__releasebuffer__", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339 * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) # <<<<<<<<<<<<<< * if sizeof(npy_intp) != sizeof(Py_ssize_t): * PyObject_Free(info.strides) */ PyObject_Free(__pyx_v_info->format); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * PyObject_Free(info.strides) * # info.shape was stored after info.strides in the same block */ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341 * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): * PyObject_Free(info.strides) # <<<<<<<<<<<<<< * # info.shape was stored after info.strides in the same block * */ PyObject_Free(__pyx_v_info->strides); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * PyObject_Free(info.strides) * # info.shape was stored after info.strides in the same block */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":825 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 828, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 831, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * * cdef inline tuple PyDataType_SHAPE(dtype d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< * else: * return () */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_empty_tuple); __pyx_r = __pyx_empty_tuple; goto __pyx_L0; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< * # Recursive utility function used in __getbuffer__ to get format * # string. The new location in the format string is returned. */ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { PyArray_Descr *__pyx_v_child = 0; int __pyx_v_endian_detector; int __pyx_v_little_endian; PyObject *__pyx_v_fields = 0; PyObject *__pyx_v_childname = NULL; PyObject *__pyx_v_new_offset = NULL; PyObject *__pyx_v_t = NULL; char *__pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; int __pyx_t_7; long __pyx_t_8; char *__pyx_t_9; __Pyx_RefNannySetupContext("_util_dtypestring", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847 * * cdef dtype child * cdef int endian_detector = 1 # <<<<<<<<<<<<<< * cdef bint little_endian = ((&endian_detector)[0] != 0) * cdef tuple fields */ __pyx_v_endian_detector = 1; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":848 * cdef dtype child * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * cdef tuple fields * */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< * fields = descr.fields[childname] * child, new_offset = fields */ if (unlikely(__pyx_v_descr->names == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(1, 851, __pyx_L1_error) } __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 851, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852 * * for childname in descr.names: * fields = descr.fields[childname] # <<<<<<<<<<<<<< * child, new_offset = fields * */ if (unlikely(__pyx_v_descr->fields == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 852, __pyx_L1_error) } __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":853 * for childname in descr.names: * fields = descr.fields[childname] * child, new_offset = fields # <<<<<<<<<<<<<< * * if (end - f) - (new_offset - offset[0]) < 15: */ if (likely(__pyx_v_fields != Py_None)) { PyObject* sequence = __pyx_v_fields; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(1, 853, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } else { __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 853, __pyx_L1_error) } if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); __pyx_t_4 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 856, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); if (!__pyx_t_7) { goto __pyx_L8_next_or; } else { } __pyx_t_7 = (__pyx_v_little_endian != 0); if (!__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_L8_next_or:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859 * * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< * raise ValueError(u"Non-native byte order not supported") * # One could encode it in the format string and have Cython */ __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); if (__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_6 = __pyx_t_7; __pyx_L7_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":860 * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * # One could encode it in the format string and have Cython * # complain instead, BUT: < and > in format strings also imply */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 860, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 860, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870 * * # Output padding bytes * while offset[0] < new_offset: # <<<<<<<<<<<<<< * f[0] = 120 # "x"; pad byte * f += 1 */ while (1) { __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_6) break; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871 * # Output padding bytes * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< * f += 1 * offset[0] += 1 */ (__pyx_v_f[0]) = 0x78; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872 * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte * f += 1 # <<<<<<<<<<<<<< * offset[0] += 1 * */ __pyx_v_f = (__pyx_v_f + 1); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":873 * f[0] = 120 # "x"; pad byte * f += 1 * offset[0] += 1 # <<<<<<<<<<<<<< * * offset[0] += child.itemsize */ __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":875 * offset[0] += 1 * * offset[0] += child.itemsize # <<<<<<<<<<<<<< * * if not PyDataType_HASFIELDS(child): */ __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< * t = child.type_num * if end - f < 5: */ __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); if (__pyx_t_6) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 * * if not PyDataType_HASFIELDS(child): * t = child.type_num # <<<<<<<<<<<<<< * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); __pyx_t_4 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short.") * */ __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 880, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short.") * */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883 * * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 98; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884 * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 66; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885 * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x68; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886 * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 72; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887 * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x69; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888 * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 73; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889 * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x6C; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890 * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 76; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891 * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x71; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892 * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 81; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893 * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x66; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894 * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x64; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895 * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x67; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896 * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x66; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897 * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x64; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898 * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x67; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":899 * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(__pyx_t_6)) { (__pyx_v_f[0]) = 79; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901 * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * f += 1 * else: */ /*else*/ { __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 901, __pyx_L1_error) } __pyx_L15:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":902 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * f += 1 # <<<<<<<<<<<<<< * else: * # Cython ignores struct boundary information ("T{...}"), */ __pyx_v_f = (__pyx_v_f + 1); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< * t = child.type_num * if end - f < 5: */ goto __pyx_L13; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906 * # Cython ignores struct boundary information ("T{...}"), * # so don't output it * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< * return f * */ /*else*/ { __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 906, __pyx_L1_error) __pyx_v_f = __pyx_t_9; } __pyx_L13:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< * fields = descr.fields[childname] * child, new_offset = fields */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":907 * # so don't output it * f = _util_dtypestring(child, f, end, offset) * return f # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_f; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< * # Recursive utility function used in __getbuffer__ to get format * # string. The new location in the format string is returned. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_child); __Pyx_XDECREF(__pyx_v_fields); __Pyx_XDECREF(__pyx_v_childname); __Pyx_XDECREF(__pyx_v_new_offset); __Pyx_XDECREF(__pyx_v_t); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< * PyArray_SetBaseObject(arr, base) * */ Py_INCREF(__pyx_v_base); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1024 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * * cdef inline object get_array_base(ndarray arr): */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< * if base is NULL: * return None */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< * return base * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1030 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< * * # Versions of the import_* functions which are more suitable for */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * _import_array() */ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_array", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036 * cdef inline int import_array() except -1: * try: * _import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1036, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 * try: * _import_array() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.multiarray failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1037, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1038, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1038, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * _import_array() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_umath", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1042, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1043, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1044, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1044, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_ufunc", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1048, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1049, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1050 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1050, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1050, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec_circular_overlap(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_circular_overlap}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "circular_overlap", __pyx_k_The_functions_defined_here_allo, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_DTYPE, __pyx_k_DTYPE, sizeof(__pyx_k_DTYPE), 0, 0, 1, 1}, {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, {&__pyx_n_s_bxmax, __pyx_k_bxmax, sizeof(__pyx_k_bxmax), 0, 0, 1, 1}, {&__pyx_n_s_bxmin, __pyx_k_bxmin, sizeof(__pyx_k_bxmin), 0, 0, 1, 1}, {&__pyx_n_s_bymax, __pyx_k_bymax, sizeof(__pyx_k_bymax), 0, 0, 1, 1}, {&__pyx_n_s_bymin, __pyx_k_bymin, sizeof(__pyx_k_bymin), 0, 0, 1, 1}, {&__pyx_n_s_circular_overlap_grid, __pyx_k_circular_overlap_grid, sizeof(__pyx_k_circular_overlap_grid), 0, 0, 1, 1}, {&__pyx_n_u_circular_overlap_grid, __pyx_k_circular_overlap_grid, sizeof(__pyx_k_circular_overlap_grid), 0, 1, 0, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_d, __pyx_k_d, sizeof(__pyx_k_d), 0, 0, 1, 1}, {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, {&__pyx_n_s_dx, __pyx_k_dx, sizeof(__pyx_k_dx), 0, 0, 1, 1}, {&__pyx_n_s_dy, __pyx_k_dy, sizeof(__pyx_k_dy), 0, 0, 1, 1}, {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1}, {&__pyx_n_s_frac, __pyx_k_frac, sizeof(__pyx_k_frac), 0, 0, 1, 1}, {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, {&__pyx_n_s_nx, __pyx_k_nx, sizeof(__pyx_k_nx), 0, 0, 1, 1}, {&__pyx_n_s_ny, __pyx_k_ny, sizeof(__pyx_k_ny), 0, 0, 1, 1}, {&__pyx_n_s_pixel_radius, __pyx_k_pixel_radius, sizeof(__pyx_k_pixel_radius), 0, 0, 1, 1}, {&__pyx_n_s_pxcen, __pyx_k_pxcen, sizeof(__pyx_k_pxcen), 0, 0, 1, 1}, {&__pyx_n_s_pxmax, __pyx_k_pxmax, sizeof(__pyx_k_pxmax), 0, 0, 1, 1}, {&__pyx_n_s_pxmin, __pyx_k_pxmin, sizeof(__pyx_k_pxmin), 0, 0, 1, 1}, {&__pyx_n_s_pycen, __pyx_k_pycen, sizeof(__pyx_k_pycen), 0, 0, 1, 1}, {&__pyx_n_s_pymax, __pyx_k_pymax, sizeof(__pyx_k_pymax), 0, 0, 1, 1}, {&__pyx_n_s_pymin, __pyx_k_pymin, sizeof(__pyx_k_pymin), 0, 0, 1, 1}, {&__pyx_n_s_r, __pyx_k_r, sizeof(__pyx_k_r), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_kp_s_regions__geometry_circular_overl, __pyx_k_regions__geometry_circular_overl, sizeof(__pyx_k_regions__geometry_circular_overl), 0, 0, 1, 0}, {&__pyx_n_s_regions__geometry_circular_overl_2, __pyx_k_regions__geometry_circular_overl_2, sizeof(__pyx_k_regions__geometry_circular_overl_2), 0, 0, 1, 1}, {&__pyx_n_s_subpixels, __pyx_k_subpixels, sizeof(__pyx_k_subpixels), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, {&__pyx_n_s_use_exact, __pyx_k_use_exact, sizeof(__pyx_k_use_exact), 0, 0, 1, 1}, {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, {&__pyx_n_s_xmax, __pyx_k_xmax, sizeof(__pyx_k_xmax), 0, 0, 1, 1}, {&__pyx_n_s_xmin, __pyx_k_xmin, sizeof(__pyx_k_xmin), 0, 0, 1, 1}, {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, {&__pyx_n_s_ymax, __pyx_k_ymax, sizeof(__pyx_k_ymax), 0, 0, 1, 1}, {&__pyx_n_s_ymin, __pyx_k_ymin, sizeof(__pyx_k_ymin), 0, 0, 1, 1}, {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 86, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error) __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 856, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1038, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 1038, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 1044, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "regions/_geometry/circular_overlap.pyx":34 * * * def circular_overlap_grid(double xmin, double xmax, double ymin, double ymax, # <<<<<<<<<<<<<< * int nx, int ny, double r, int use_exact, * int subpixels): */ __pyx_tuple__8 = PyTuple_Pack(28, __pyx_n_s_xmin, __pyx_n_s_xmax, __pyx_n_s_ymin, __pyx_n_s_ymax, __pyx_n_s_nx, __pyx_n_s_ny, __pyx_n_s_r, __pyx_n_s_use_exact, __pyx_n_s_subpixels, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_dx, __pyx_n_s_dy, __pyx_n_s_d, __pyx_n_s_pixel_radius, __pyx_n_s_bxmin, __pyx_n_s_bxmax, __pyx_n_s_bymin, __pyx_n_s_bymax, __pyx_n_s_pxmin, __pyx_n_s_pxcen, __pyx_n_s_pxmax, __pyx_n_s_pymin, __pyx_n_s_pycen, __pyx_n_s_pymax, __pyx_n_s_frac); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(9, 0, 28, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_regions__geometry_circular_overl, __pyx_n_s_circular_overlap_grid, 34, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 sizeof(PyTypeObject), #else sizeof(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error) __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error) __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 918, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __pyx_t_1 = PyImport_ImportModule("regions._geometry.core"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ImportFunction(__pyx_t_1, "area_arc", (void (**)(void))&__pyx_f_7regions_9_geometry_4core_area_arc, "double (double, double, double, double, double)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ImportFunction(__pyx_t_1, "area_triangle", (void (**)(void))&__pyx_f_7regions_9_geometry_4core_area_triangle, "double (double, double, double, double, double, double)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ImportFunction(__pyx_t_1, "floor_sqrt", (void (**)(void))&__pyx_f_7regions_9_geometry_4core_floor_sqrt, "double (double)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) Py_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } #if PY_MAJOR_VERSION < 3 #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC void #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #else #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyObject * #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC initcircular_overlap(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC initcircular_overlap(void) #else __Pyx_PyMODINIT_FUNC PyInit_circular_overlap(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_circular_overlap(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec_circular_overlap(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module 'circular_overlap' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_circular_overlap(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("circular_overlap", __pyx_methods, __pyx_k_The_functions_defined_here_allo, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_regions___geometry__circular_overlap) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "regions._geometry.circular_overlap")) { if (unlikely(PyDict_SetItemString(modules, "regions._geometry.circular_overlap", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); (void)__Pyx_modinit_type_init_code(); if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error; (void)__Pyx_modinit_variable_import_code(); if (unlikely(__Pyx_modinit_function_import_code() != 0)) goto __pyx_L1_error; /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "regions/_geometry/circular_overlap.pyx":11 * unicode_literals) * * import numpy as np # <<<<<<<<<<<<<< * cimport numpy as np * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/circular_overlap.pyx":15 * * * __all__ = ['circular_overlap_grid'] # <<<<<<<<<<<<<< * * */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_u_circular_overlap_grid); __Pyx_GIVEREF(__pyx_n_u_circular_overlap_grid); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_u_circular_overlap_grid); if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_t_1) < 0) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/circular_overlap.pyx":25 * * * DTYPE = np.float64 # <<<<<<<<<<<<<< * ctypedef np.float64_t DTYPE_t * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE, __pyx_t_2) < 0) __PYX_ERR(0, 25, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/circular_overlap.pyx":34 * * * def circular_overlap_grid(double xmin, double xmax, double ymin, double ymax, # <<<<<<<<<<<<<< * int nx, int ny, double r, int use_exact, * int subpixels): */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7regions_9_geometry_16circular_overlap_1circular_overlap_grid, NULL, __pyx_n_s_regions__geometry_circular_overl_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_circular_overlap_grid, __pyx_t_2) < 0) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/circular_overlap.pyx":1 * # Licensed under a 3-clause BSD style license - see LICENSE.rst # <<<<<<<<<<<<<< * # cython: language_level=3 * """ */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init regions._geometry.circular_overlap", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init regions._geometry.circular_overlap"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* IsLittleEndian */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) { union { uint32_t u32; uint8_t u8[4]; } S; S.u32 = 0x01020304; return S.u8[0] == 4; } /* BufferFormatCheck */ static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type) { stack[0].field = &ctx->root; stack[0].parent_offset = 0; ctx->root.type = type; ctx->root.name = "buffer dtype"; ctx->root.offset = 0; ctx->head = stack; ctx->head->field = &ctx->root; ctx->fmt_offset = 0; ctx->head->parent_offset = 0; ctx->new_packmode = '@'; ctx->enc_packmode = '@'; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->is_complex = 0; ctx->is_valid_array = 0; ctx->struct_alignment = 0; while (type->typegroup == 'S') { ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = 0; type = type->fields->type; } } static int __Pyx_BufFmt_ParseNumber(const char** ts) { int count; const char* t = *ts; if (*t < '0' || *t > '9') { return -1; } else { count = *t++ - '0'; while (*t >= '0' && *t <= '9') { count *= 10; count += *t++ - '0'; } } *ts = t; return count; } static int __Pyx_BufFmt_ExpectNumber(const char **ts) { int number = __Pyx_BufFmt_ParseNumber(ts); if (number == -1) PyErr_Format(PyExc_ValueError,\ "Does not understand character buffer dtype format string ('%c')", **ts); return number; } static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { PyErr_Format(PyExc_ValueError, "Unexpected format string character: '%c'", ch); } static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { switch (ch) { case 'c': return "'char'"; case 'b': return "'signed char'"; case 'B': return "'unsigned char'"; case 'h': return "'short'"; case 'H': return "'unsigned short'"; case 'i': return "'int'"; case 'I': return "'unsigned int'"; case 'l': return "'long'"; case 'L': return "'unsigned long'"; case 'q': return "'long long'"; case 'Q': return "'unsigned long long'"; case 'f': return (is_complex ? "'complex float'" : "'float'"); case 'd': return (is_complex ? "'complex double'" : "'double'"); case 'g': return (is_complex ? "'complex long double'" : "'long double'"); case 'T': return "a struct"; case 'O': return "Python object"; case 'P': return "a pointer"; case 's': case 'p': return "a string"; case 0: return "end"; default: return "unparseable format string"; } } static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return 2; case 'i': case 'I': case 'l': case 'L': return 4; case 'q': case 'Q': return 8; case 'f': return (is_complex ? 8 : 4); case 'd': return (is_complex ? 16 : 8); case 'g': { PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); return 0; } case 'O': case 'P': return sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { switch (ch) { case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(short); case 'i': case 'I': return sizeof(int); case 'l': case 'L': return sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(float) * (is_complex ? 2 : 1); case 'd': return sizeof(double) * (is_complex ? 2 : 1); case 'g': return sizeof(long double) * (is_complex ? 2 : 1); case 'O': case 'P': return sizeof(void*); default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } typedef struct { char c; short x; } __Pyx_st_short; typedef struct { char c; int x; } __Pyx_st_int; typedef struct { char c; long x; } __Pyx_st_long; typedef struct { char c; float x; } __Pyx_st_float; typedef struct { char c; double x; } __Pyx_st_double; typedef struct { char c; long double x; } __Pyx_st_longdouble; typedef struct { char c; void *x; } __Pyx_st_void_p; #ifdef HAVE_LONG_LONG typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_st_float) - sizeof(float); case 'd': return sizeof(__Pyx_st_double) - sizeof(double); case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } /* These are for computing the padding at the end of the struct to align on the first member of the struct. This will probably the same as above, but we don't have any guarantees. */ typedef struct { short x; char c; } __Pyx_pad_short; typedef struct { int x; char c; } __Pyx_pad_int; typedef struct { long x; char c; } __Pyx_pad_long; typedef struct { float x; char c; } __Pyx_pad_float; typedef struct { double x; char c; } __Pyx_pad_double; typedef struct { long double x; char c; } __Pyx_pad_longdouble; typedef struct { void *x; char c; } __Pyx_pad_void_p; #ifdef HAVE_LONG_LONG typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { switch (ch) { case 'c': return 'H'; case 'b': case 'h': case 'i': case 'l': case 'q': case 's': case 'p': return 'I'; case 'B': case 'H': case 'I': case 'L': case 'Q': return 'U'; case 'f': case 'd': case 'g': return (is_complex ? 'C' : 'R'); case 'O': return 'O'; case 'P': return 'P'; default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { if (ctx->head == NULL || ctx->head->field == &ctx->root) { const char* expected; const char* quote; if (ctx->head == NULL) { expected = "end"; quote = ""; } else { expected = ctx->head->field->type->name; quote = "'"; } PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected %s%s%s but got %s", quote, expected, quote, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); } else { __Pyx_StructField* field = ctx->head->field; __Pyx_StructField* parent = (ctx->head - 1)->field; PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), parent->type->name, field->name); } } static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { char group; size_t size, offset, arraysize = 1; if (ctx->enc_type == 0) return 0; if (ctx->head->field->type->arraysize[0]) { int i, ndim = 0; if (ctx->enc_type == 's' || ctx->enc_type == 'p') { ctx->is_valid_array = ctx->head->field->type->ndim == 1; ndim = 1; if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %zu", ctx->head->field->type->arraysize[0], ctx->enc_count); return -1; } } if (!ctx->is_valid_array) { PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", ctx->head->field->type->ndim, ndim); return -1; } for (i = 0; i < ctx->head->field->type->ndim; i++) { arraysize *= ctx->head->field->type->arraysize[i]; } ctx->is_valid_array = 0; ctx->enc_count = 1; } group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); do { __Pyx_StructField* field = ctx->head->field; __Pyx_TypeInfo* type = field->type; if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); } else { size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); } if (ctx->enc_packmode == '@') { size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); size_t align_mod_offset; if (align_at == 0) return -1; align_mod_offset = ctx->fmt_offset % align_at; if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; if (ctx->struct_alignment == 0) ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, ctx->is_complex); } if (type->size != size || type->typegroup != group) { if (type->typegroup == 'C' && type->fields != NULL) { size_t parent_offset = ctx->head->parent_offset + field->offset; ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = parent_offset; continue; } if ((type->typegroup == 'H' || group == 'H') && type->size == size) { } else { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } } offset = ctx->head->parent_offset + field->offset; if (ctx->fmt_offset != offset) { PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); return -1; } ctx->fmt_offset += size; if (arraysize) ctx->fmt_offset += (arraysize - 1) * size; --ctx->enc_count; while (1) { if (field == &ctx->root) { ctx->head = NULL; if (ctx->enc_count != 0) { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } break; } ctx->head->field = ++field; if (field->type == NULL) { --ctx->head; field = ctx->head->field; continue; } else if (field->type->typegroup == 'S') { size_t parent_offset = ctx->head->parent_offset + field->offset; if (field->type->fields->type == NULL) continue; field = field->type->fields; ++ctx->head; ctx->head->field = field; ctx->head->parent_offset = parent_offset; break; } else { break; } } } while (ctx->enc_count); ctx->enc_type = 0; ctx->is_complex = 0; return 0; } static PyObject * __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { const char *ts = *tsp; int i = 0, number; int ndim = ctx->head->field->type->ndim; ; ++ts; if (ctx->new_count != 1) { PyErr_SetString(PyExc_ValueError, "Cannot handle repeated arrays in format string"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; while (*ts && *ts != ')') { switch (*ts) { case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; default: break; } number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) return PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %d", ctx->head->field->type->arraysize[i], number); if (*ts != ',' && *ts != ')') return PyErr_Format(PyExc_ValueError, "Expected a comma in format string, got '%c'", *ts); if (*ts == ',') ts++; i++; } if (i != ndim) return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", ctx->head->field->type->ndim, i); if (!*ts) { PyErr_SetString(PyExc_ValueError, "Unexpected end of format string, expected ')'"); return NULL; } ctx->is_valid_array = 1; ctx->new_count = 1; *tsp = ++ts; return Py_None; } static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { int got_Z = 0; while (1) { switch(*ts) { case 0: if (ctx->enc_type != 0 && ctx->head == NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; if (ctx->head != NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } return ts; case ' ': case '\r': case '\n': ++ts; break; case '<': if (!__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '>': case '!': if (__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '=': case '@': case '^': ctx->new_packmode = *ts++; break; case 'T': { const char* ts_after_sub; size_t i, struct_count = ctx->new_count; size_t struct_alignment = ctx->struct_alignment; ctx->new_count = 1; ++ts; if (*ts != '{') { PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; ctx->enc_count = 0; ctx->struct_alignment = 0; ++ts; ts_after_sub = ts; for (i = 0; i != struct_count; ++i) { ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); if (!ts_after_sub) return NULL; } ts = ts_after_sub; if (struct_alignment) ctx->struct_alignment = struct_alignment; } break; case '}': { size_t alignment = ctx->struct_alignment; ++ts; if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; if (alignment && ctx->fmt_offset % alignment) { ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); } } return ts; case 'x': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->fmt_offset += ctx->new_count; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->enc_packmode = ctx->new_packmode; ++ts; break; case 'Z': got_Z = 1; ++ts; if (*ts != 'f' && *ts != 'd' && *ts != 'g') { __Pyx_BufFmt_RaiseUnexpectedChar('Z'); return NULL; } CYTHON_FALLTHROUGH; case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': case 'l': case 'L': case 'q': case 'Q': case 'f': case 'd': case 'g': case 'O': case 'p': if (ctx->enc_type == *ts && got_Z == ctx->is_complex && ctx->enc_packmode == ctx->new_packmode) { ctx->enc_count += ctx->new_count; ctx->new_count = 1; got_Z = 0; ++ts; break; } CYTHON_FALLTHROUGH; case 's': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_count = ctx->new_count; ctx->enc_packmode = ctx->new_packmode; ctx->enc_type = *ts; ctx->is_complex = got_Z; ++ts; ctx->new_count = 1; got_Z = 0; break; case ':': ++ts; while(*ts != ':') ++ts; ++ts; break; case '(': if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; break; default: { int number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; ctx->new_count = (size_t)number; } } } } /* BufferGetAndValidate */ static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { if (unlikely(info->buf == NULL)) return; if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; __Pyx_ReleaseBuffer(info); } static void __Pyx_ZeroBuffer(Py_buffer* buf) { buf->buf = NULL; buf->obj = NULL; buf->strides = __Pyx_zeros; buf->shape = __Pyx_zeros; buf->suboffsets = __Pyx_minusones; } static int __Pyx__GetBufferAndValidate( Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack) { buf->buf = NULL; if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { __Pyx_ZeroBuffer(buf); return -1; } if (unlikely(buf->ndim != nd)) { PyErr_Format(PyExc_ValueError, "Buffer has wrong number of dimensions (expected %d, got %d)", nd, buf->ndim); goto fail; } if (!cast) { __Pyx_BufFmt_Context ctx; __Pyx_BufFmt_Init(&ctx, stack, dtype); if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; } if (unlikely((size_t)buf->itemsize != dtype->size)) { PyErr_Format(PyExc_ValueError, "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", buf->itemsize, (buf->itemsize > 1) ? "s" : "", dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); goto fail; } if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; return 0; fail:; __Pyx_SafeReleaseBuffer(buf); return -1; } /* BufferIndexError */ static void __Pyx_RaiseBufferIndexError(int axis) { PyErr_Format(PyExc_IndexError, "Out of bounds on buffer access (axis %d)", axis); } /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* WriteUnraisableException */ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback, CYTHON_UNUSED int nogil) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_PyThreadState_declare #ifdef WITH_THREAD PyGILState_STATE state; if (nogil) state = PyGILState_Ensure(); #ifdef _MSC_VER else state = (PyGILState_STATE)-1; #endif #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } #ifdef WITH_THREAD if (nogil) PyGILState_Release(state); #endif } /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* DictGetItem */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); if (unlikely(!value)) { if (!PyErr_Occurred()) { if (unlikely(PyTuple_Check(key))) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) { PyErr_SetObject(PyExc_KeyError, args); Py_DECREF(args); } } else { PyErr_SetObject(PyExc_KeyError, key); } } return NULL; } Py_INCREF(value); return value; } #endif /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* RaiseNoneIterError */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; #ifdef Py_LIMITED_API PyObject *py_basicsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #ifndef Py_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if ((size_t)basicsize < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(result); return NULL; } #endif /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.')) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); return -1; } static void __Pyx_ReleaseBuffer(Py_buffer *view) { PyObject *obj = view->obj; if (!obj) return; if (PyObject_CheckBuffer(obj)) { PyBuffer_Release(view); return; } if ((0)) {} else if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); view->obj = NULL; Py_DECREF(obj); } #endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return ::std::complex< float >(x, y); } #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return x + y*(__pyx_t_float_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { __pyx_t_float_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabsf(b.real) >= fabsf(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { float r = b.imag / b.real; float s = (float)(1.0) / (b.real + b.imag * r); return __pyx_t_float_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { float r = b.real / b.imag; float s = (float)(1.0) / (b.imag + b.real * r); return __pyx_t_float_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else { float denom = b.real * b.real + b.imag * b.imag; return __pyx_t_float_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrtf(z.real*z.real + z.imag*z.imag); #else return hypotf(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; float r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { float denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(a, a); case 3: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, a); case 4: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = powf(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2f(0.0, -1.0); } } else { r = __Pyx_c_abs_float(a); theta = atan2f(a.imag, a.real); } lnr = logf(r); z_r = expf(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cosf(z_theta); z.imag = z_r * sinf(z_theta); return z; } #endif #endif /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return ::std::complex< double >(x, y); } #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return x + y*(__pyx_t_double_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { __pyx_t_double_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabs(b.real) >= fabs(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { double r = b.imag / b.real; double s = (double)(1.0) / (b.real + b.imag * r); return __pyx_t_double_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { double r = b.real / b.imag; double s = (double)(1.0) / (b.imag + b.real * r); return __pyx_t_double_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else { double denom = b.real * b.real + b.imag * b.imag; return __pyx_t_double_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrt(z.real*z.real + z.imag*z.imag); #else return hypot(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; double r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { double denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(a, a); case 3: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, a); case 4: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = pow(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2(0.0, -1.0); } } else { r = __Pyx_c_abs_double(a); theta = atan2(a.imag, a.real); } lnr = log(r); z_r = exp(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cos(z_theta); z.imag = z_r * sin(z_theta); return z; } #endif #endif /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(enum NPY_TYPES) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(enum NPY_TYPES) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntFromPy */ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (unsigned int) 1), const_zero = (unsigned int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(unsigned int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (unsigned int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned int) 0; case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0]) case 2: if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) { return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; case 3: if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) { return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; case 4: if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT) { return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (unsigned int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(unsigned int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned int) 0; case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, +digits[0]) case -2: if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 2: if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case -3: if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 3: if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case -4: if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 4: if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; } #endif if (sizeof(unsigned int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else unsigned int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (unsigned int) -1; } } else { unsigned int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (unsigned int) -1; val = __Pyx_PyInt_As_unsigned_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned int"); return (unsigned int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned int"); return (unsigned int) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i= 0x02070000 if (!PyCapsule_IsValid(cobj, sig)) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj)); goto bad; } tmp.p = PyCapsule_GetPointer(cobj, sig); #else {const char *desc, *s1, *s2; desc = (const char *)PyCObject_GetDesc(cobj); if (!desc) goto bad; s1 = desc; s2 = sig; while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } if (*s1 != *s2) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", PyModule_GetName(module), funcname, sig, desc); goto bad; } tmp.p = PyCObject_AsVoidPtr(cobj);} #endif *f = tmp.fp; if (!(*f)) goto bad; Py_DECREF(d); return 0; bad: Py_XDECREF(d); return -1; } #endif /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ regions-0.4/regions/_geometry/circular_overlap.pyx0000644000076600000240000002043513501414013022616 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst # cython: language_level=3 """ The functions defined here allow one to determine the exact area of overlap of a rectangle and a circle (written by Thomas Robitaille). """ from __future__ import (absolute_import, division, print_function, unicode_literals) import numpy as np cimport numpy as np __all__ = ['circular_overlap_grid'] cdef extern from "math.h": double asin(double x) double sin(double x) double sqrt(double x) DTYPE = np.float64 ctypedef np.float64_t DTYPE_t # NOTE: Here we need to make sure we use cimport to import the C functions from # core (since these were defined with cdef). This also requires the core.pxd # file to exist with the function signatures. from .core cimport area_arc, area_triangle, floor_sqrt def circular_overlap_grid(double xmin, double xmax, double ymin, double ymax, int nx, int ny, double r, int use_exact, int subpixels): """ circular_overlap_grid(xmin, xmax, ymin, ymax, nx, ny, r, use_exact, subpixels) Area of overlap between a circle and a pixel grid. The circle is centered on the origin. Parameters ---------- xmin, xmax, ymin, ymax : float Extent of the grid in the x and y direction. nx, ny : int Grid dimensions. r : float The radius of the circle. use_exact : 0 or 1 If ``1`` calculates exact overlap, if ``0`` uses ``subpixel`` number of subpixels to calculate the overlap. subpixels : int Each pixel resampled by this factor in each dimension, thus each pixel is divided into ``subpixels ** 2`` subpixels. Returns ------- frac : `~numpy.ndarray` (float) 2-d array of shape (ny, nx) giving the fraction of the overlap. """ cdef unsigned int i, j cdef double x, y, dx, dy, d, pixel_radius cdef double bxmin, bxmax, bymin, bymax cdef double pxmin, pxcen, pxmax, pymin, pycen, pymax # Define output array cdef np.ndarray[DTYPE_t, ndim=2] frac = np.zeros([ny, nx], dtype=DTYPE) # Find the width of each element in x and y dx = (xmax - xmin) / nx dy = (ymax - ymin) / ny # Find the radius of a single pixel pixel_radius = 0.5 * sqrt(dx * dx + dy * dy) # Define bounding box bxmin = -r - 0.5 * dx bxmax = +r + 0.5 * dx bymin = -r - 0.5 * dy bymax = +r + 0.5 * dy for i in range(nx): pxmin = xmin + i * dx # lower end of pixel pxcen = pxmin + dx * 0.5 pxmax = pxmin + dx # upper end of pixel if pxmax > bxmin and pxmin < bxmax: for j in range(ny): pymin = ymin + j * dy pycen = pymin + dy * 0.5 pymax = pymin + dy if pymax > bymin and pymin < bymax: # Distance from circle center to pixel center. d = sqrt(pxcen * pxcen + pycen * pycen) # If pixel center is "well within" circle, count full # pixel. if d < r - pixel_radius: frac[j, i] = 1. # If pixel center is "close" to circle border, find # overlap. elif d < r + pixel_radius: # Either do exact calculation or use subpixel # sampling: if use_exact: frac[j, i] = circular_overlap_single_exact( pxmin, pymin, pxmax, pymax, r) / (dx * dy) else: frac[j, i] = circular_overlap_single_subpixel( pxmin, pymin, pxmax, pymax, r, subpixels) # Otherwise, it is fully outside circle. # No action needed. return frac # NOTE: The following two functions use cdef because they are not # intended to be called from the Python code. Using def makes them # callable from outside, but also slower. In any case, these aren't useful # to call from outside because they only operate on a single pixel. cdef double circular_overlap_single_subpixel(double x0, double y0, double x1, double y1, double r, int subpixels): """Return the fraction of overlap between a circle and a single pixel with given extent, using a sub-pixel sampling method.""" cdef unsigned int i, j cdef double x, y, dx, dy, r_squared cdef double frac = 0. # Accumulator. dx = (x1 - x0) / subpixels dy = (y1 - y0) / subpixels r_squared = r ** 2 x = x0 - 0.5 * dx for i in range(subpixels): x += dx y = y0 - 0.5 * dy for j in range(subpixels): y += dy if x * x + y * y < r_squared: frac += 1. return frac / (subpixels * subpixels) cdef double circular_overlap_single_exact(double xmin, double ymin, double xmax, double ymax, double r): """ Area of overlap of a rectangle and a circle """ if 0. <= xmin: if 0. <= ymin: return circular_overlap_core(xmin, ymin, xmax, ymax, r) elif 0. >= ymax: return circular_overlap_core(-ymax, xmin, -ymin, xmax, r) else: return circular_overlap_single_exact(xmin, ymin, xmax, 0., r) \ + circular_overlap_single_exact(xmin, 0., xmax, ymax, r) elif 0. >= xmax: if 0. <= ymin: return circular_overlap_core(-xmax, ymin, -xmin, ymax, r) elif 0. >= ymax: return circular_overlap_core(-xmax, -ymax, -xmin, -ymin, r) else: return circular_overlap_single_exact(xmin, ymin, xmax, 0., r) \ + circular_overlap_single_exact(xmin, 0., xmax, ymax, r) else: if 0. <= ymin: return circular_overlap_single_exact(xmin, ymin, 0., ymax, r) \ + circular_overlap_single_exact(0., ymin, xmax, ymax, r) if 0. >= ymax: return circular_overlap_single_exact(xmin, ymin, 0., ymax, r) \ + circular_overlap_single_exact(0., ymin, xmax, ymax, r) else: return circular_overlap_single_exact(xmin, ymin, 0., 0., r) \ + circular_overlap_single_exact(0., ymin, xmax, 0., r) \ + circular_overlap_single_exact(xmin, 0., 0., ymax, r) \ + circular_overlap_single_exact(0., 0., xmax, ymax, r) cdef double circular_overlap_core(double xmin, double ymin, double xmax, double ymax, double r): """ Assumes that the center of the circle is <= xmin, ymin (can always modify input to conform to this). """ cdef double area, d1, d2, x1, x2, y1, y2 if xmin * xmin + ymin * ymin > r * r: area = 0. elif xmax * xmax + ymax * ymax < r * r: area = (xmax - xmin) * (ymax - ymin) else: area = 0. d1 = floor_sqrt(xmax * xmax + ymin * ymin) d2 = floor_sqrt(xmin * xmin + ymax * ymax) if d1 < r and d2 < r: x1, y1 = floor_sqrt(r * r - ymax * ymax), ymax x2, y2 = xmax, floor_sqrt(r * r - xmax * xmax) area = ((xmax - xmin) * (ymax - ymin) - area_triangle(x1, y1, x2, y2, xmax, ymax) + area_arc(x1, y1, x2, y2, r)) elif d1 < r: x1, y1 = xmin, floor_sqrt(r * r - xmin * xmin) x2, y2 = xmax, floor_sqrt(r * r - xmax * xmax) area = (area_arc(x1, y1, x2, y2, r) + area_triangle(x1, y1, x1, ymin, xmax, ymin) + area_triangle(x1, y1, x2, ymin, x2, y2)) elif d2 < r: x1, y1 = floor_sqrt(r * r - ymin * ymin), ymin x2, y2 = floor_sqrt(r * r - ymax * ymax), ymax area = (area_arc(x1, y1, x2, y2, r) + area_triangle(x1, y1, xmin, y1, xmin, ymax) + area_triangle(x1, y1, xmin, y2, x2, y2)) else: x1, y1 = floor_sqrt(r * r - ymin * ymin), ymin x2, y2 = xmin, floor_sqrt(r * r - xmin * xmin) area = (area_arc(x1, y1, x2, y2, r) + area_triangle(x1, y1, x2, y2, xmin, ymin)) return area regions-0.4/regions/_geometry/core.c0000644000076600000240000134305113501657424017636 0ustar deilstaff00000000000000/* Generated by Cython 0.29.6 */ #define PY_SSIZE_T_CLEAN #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_6" #define CYTHON_HEX_VERSION 0x001D06F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #ifndef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #define PyObject_Unicode PyObject_Str #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_ERR(f_index, lineno, Ln_error) \ { \ __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__regions___geometry__core #define __PYX_HAVE_API__regions___geometry__core /* Early includes */ #include #include #include "numpy/arrayobject.h" #include "numpy/ufuncobject.h" #include "math.h" #include "pythread.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; /* Header.proto */ #if !defined(CYTHON_CCOMPLEX) #if defined(__cplusplus) #define CYTHON_CCOMPLEX 1 #elif defined(_Complex_I) #define CYTHON_CCOMPLEX 1 #else #define CYTHON_CCOMPLEX 0 #endif #endif #if CYTHON_CCOMPLEX #ifdef __cplusplus #include #else #include #endif #endif #if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) #undef _Complex_I #define _Complex_I 1.0fj #endif static const char *__pyx_f[] = { "regions/_geometry/core.pyx", "__init__.pxd", "type.pxd", "bool.pxd", "complex.pxd", }; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t */ typedef npy_int8 __pyx_t_5numpy_int8_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t */ typedef npy_int16 __pyx_t_5numpy_int16_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< * ctypedef npy_int64 int64_t * #ctypedef npy_int96 int96_t */ typedef npy_int32 __pyx_t_5numpy_int32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< * #ctypedef npy_int96 int96_t * #ctypedef npy_int128 int128_t */ typedef npy_int64 __pyx_t_5numpy_int64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< * ctypedef npy_uint64 uint64_t * #ctypedef npy_uint96 uint96_t */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":786 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< * #ctypedef npy_uint96 uint96_t * #ctypedef npy_uint128 uint128_t */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< * ctypedef npy_float64 float64_t * #ctypedef npy_float80 float80_t */ typedef npy_float32 __pyx_t_5numpy_float32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< * #ctypedef npy_float80 float80_t * #ctypedef npy_float128 float128_t */ typedef npy_float64 __pyx_t_5numpy_float64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t */ typedef npy_long __pyx_t_5numpy_int_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< * ctypedef npy_longlong longlong_t * */ typedef npy_longlong __pyx_t_5numpy_long_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< * * ctypedef npy_ulong uint_t */ typedef npy_longlong __pyx_t_5numpy_longlong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t */ typedef npy_ulong __pyx_t_5numpy_uint_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulonglong_t * */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":806 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< * * ctypedef npy_intp intp_t */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< * ctypedef npy_uintp uintp_t * */ typedef npy_intp __pyx_t_5numpy_intp_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":809 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< * * ctypedef npy_double float_t */ typedef npy_uintp __pyx_t_5numpy_uintp_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t */ typedef npy_double __pyx_t_5numpy_float_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< * ctypedef npy_longdouble longdouble_t * */ typedef npy_double __pyx_t_5numpy_double_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cfloat cfloat_t */ typedef npy_longdouble __pyx_t_5numpy_longdouble_t; /* "regions/_geometry/core.pyx":26 * * DTYPE = np.float64 * ctypedef np.float64_t DTYPE_t # <<<<<<<<<<<<<< * * cimport cython */ typedef __pyx_t_5numpy_float64_t __pyx_t_7regions_9_geometry_4core_DTYPE_t; /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< float > __pyx_t_float_complex; #else typedef float _Complex __pyx_t_float_complex; #endif #else typedef struct { float real, imag; } __pyx_t_float_complex; #endif static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< double > __pyx_t_double_complex; #else typedef double _Complex __pyx_t_double_complex; #endif #else typedef struct { double real, imag; } __pyx_t_double_complex; #endif static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); /*--- Type declarations ---*/ /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< * ctypedef npy_clongdouble clongdouble_t * */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":817 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cdouble complex_t */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":819 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew1(a): */ typedef npy_cdouble __pyx_t_5numpy_complex_t; struct __pyx_t_7regions_9_geometry_4core_point; typedef struct __pyx_t_7regions_9_geometry_4core_point __pyx_t_7regions_9_geometry_4core_point; struct __pyx_t_7regions_9_geometry_4core_intersections; typedef struct __pyx_t_7regions_9_geometry_4core_intersections __pyx_t_7regions_9_geometry_4core_intersections; /* "regions/_geometry/core.pyx":31 * * * ctypedef struct point: # <<<<<<<<<<<<<< * double x * double y */ struct __pyx_t_7regions_9_geometry_4core_point { double x; double y; }; /* "regions/_geometry/core.pyx":36 * * * ctypedef struct intersections: # <<<<<<<<<<<<<< * point p1 * point p2 */ struct __pyx_t_7regions_9_geometry_4core_intersections { __pyx_t_7regions_9_geometry_4core_point p1; __pyx_t_7regions_9_geometry_4core_point p2; }; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); /* None.proto */ static CYTHON_INLINE long __Pyx_mod_long(long, long); /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto #define __PYX_HAVE_RT_ImportType_proto enum __Pyx_ImportType_CheckSize { __Pyx_ImportType_CheckSize_Error = 0, __Pyx_ImportType_CheckSize_Warn = 1, __Pyx_ImportType_CheckSize_Ignore = 2 }; static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus #define __Pyx_CREAL(z) ((z).real()) #define __Pyx_CIMAG(z) ((z).imag()) #else #define __Pyx_CREAL(z) (__real__(z)) #define __Pyx_CIMAG(z) (__imag__(z)) #endif #else #define __Pyx_CREAL(z) ((z).real) #define __Pyx_CIMAG(z) ((z).imag) #endif #if defined(__cplusplus) && CYTHON_CCOMPLEX\ && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) #define __Pyx_SET_CREAL(z,x) ((z).real(x)) #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) #else #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_float(a, b) ((a)==(b)) #define __Pyx_c_sum_float(a, b) ((a)+(b)) #define __Pyx_c_diff_float(a, b) ((a)-(b)) #define __Pyx_c_prod_float(a, b) ((a)*(b)) #define __Pyx_c_quot_float(a, b) ((a)/(b)) #define __Pyx_c_neg_float(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_float(z) ((z)==(float)0) #define __Pyx_c_conj_float(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_float(z) (::std::abs(z)) #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_float(z) ((z)==0) #define __Pyx_c_conj_float(z) (conjf(z)) #if 1 #define __Pyx_c_abs_float(z) (cabsf(z)) #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); #endif #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_double(a, b) ((a)==(b)) #define __Pyx_c_sum_double(a, b) ((a)+(b)) #define __Pyx_c_diff_double(a, b) ((a)-(b)) #define __Pyx_c_prod_double(a, b) ((a)*(b)) #define __Pyx_c_quot_double(a, b) ((a)/(b)) #define __Pyx_c_neg_double(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_double(z) ((z)==(double)0) #define __Pyx_c_conj_double(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_double(z) (::std::abs(z)) #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_double(z) ((z)==0) #define __Pyx_c_conj_double(z) (conj(z)) #if 1 #define __Pyx_c_abs_double(z) (cabs(z)) #define __Pyx_c_pow_double(a, b) (cpow(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); #endif #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* FunctionExport.proto */ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'cpython.buffer' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdio' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.type' */ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; /* Module declarations from 'cpython.version' */ /* Module declarations from 'cpython.exc' */ /* Module declarations from 'cpython.module' */ /* Module declarations from 'cpython.mem' */ /* Module declarations from 'cpython.tuple' */ /* Module declarations from 'cpython.list' */ /* Module declarations from 'cpython.sequence' */ /* Module declarations from 'cpython.mapping' */ /* Module declarations from 'cpython.iterator' */ /* Module declarations from 'cpython.number' */ /* Module declarations from 'cpython.int' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.bool' */ static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; /* Module declarations from 'cpython.long' */ /* Module declarations from 'cpython.float' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.complex' */ static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; /* Module declarations from 'cpython.string' */ /* Module declarations from 'cpython.unicode' */ /* Module declarations from 'cpython.dict' */ /* Module declarations from 'cpython.instance' */ /* Module declarations from 'cpython.function' */ /* Module declarations from 'cpython.method' */ /* Module declarations from 'cpython.weakref' */ /* Module declarations from 'cpython.getargs' */ /* Module declarations from 'cpython.pythread' */ /* Module declarations from 'cpython.pystate' */ /* Module declarations from 'cpython.cobject' */ /* Module declarations from 'cpython.oldbuffer' */ /* Module declarations from 'cpython.set' */ /* Module declarations from 'cpython.bytes' */ /* Module declarations from 'cpython.pycapsule' */ /* Module declarations from 'cpython' */ /* Module declarations from 'cpython.object' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'numpy' */ /* Module declarations from 'numpy' */ static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ /* Module declarations from 'cython' */ /* Module declarations from 'regions._geometry.core' */ static double __pyx_f_7regions_9_geometry_4core_distance(double, double, double, double); /*proto*/ static double __pyx_f_7regions_9_geometry_4core_area_triangle(double, double, double, double, double, double); /*proto*/ static double __pyx_f_7regions_9_geometry_4core_area_arc_unit(double, double, double, double); /*proto*/ static int __pyx_f_7regions_9_geometry_4core_in_triangle(double, double, double, double, double, double, double, double); /*proto*/ static double __pyx_f_7regions_9_geometry_4core_overlap_area_triangle_unit_circle(double, double, double, double, double, double); /*proto*/ static __pyx_t_7regions_9_geometry_4core_intersections __pyx_f_7regions_9_geometry_4core_circle_line(double, double, double, double); /*proto*/ static __pyx_t_7regions_9_geometry_4core_point __pyx_f_7regions_9_geometry_4core_circle_segment_single2(double, double, double, double); /*proto*/ static __pyx_t_7regions_9_geometry_4core_intersections __pyx_f_7regions_9_geometry_4core_circle_segment(double, double, double, double); /*proto*/ #define __Pyx_MODULE_NAME "regions._geometry.core" extern int __pyx_module_is_main_regions___geometry__core; int __pyx_module_is_main_regions___geometry__core = 0; /* Implementation of 'regions._geometry.core' */ static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_ImportError; static const char __pyx_k_np[] = "np"; static const char __pyx_k_pi[] = "pi"; static const char __pyx_k_all[] = "__all__"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_DTYPE[] = "DTYPE"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_float64[] = "float64"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_RuntimeError[] = "RuntimeError"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_elliptical_overlap_grid[] = "elliptical_overlap_grid"; static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; static const char __pyx_k_The_functions_here_are_the_core[] = "The functions here are the core geometry functions."; static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; static const char __pyx_k_ERROR_vertices_did_not_sort_corr[] = "ERROR: vertices did not sort correctly"; static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; static PyObject *__pyx_n_s_DTYPE; static PyObject *__pyx_kp_u_ERROR_vertices_did_not_sort_corr; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; static PyObject *__pyx_n_s_RuntimeError; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_all; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_u_elliptical_overlap_grid; static PyObject *__pyx_n_s_float64; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_name; static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; static PyObject *__pyx_n_s_pi; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_test; static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; /* Late includes */ /* "regions/_geometry/core.pyx":41 * * * cdef double floor_sqrt(double x): # <<<<<<<<<<<<<< * """ * In some of the geometrical functions, we have to take the sqrt of a number */ static double __pyx_f_7regions_9_geometry_4core_floor_sqrt(double __pyx_v_x) { double __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("floor_sqrt", 0); /* "regions/_geometry/core.pyx":52 * to be positive on paper. * """ * if x > 0: # <<<<<<<<<<<<<< * return sqrt(x) * else: */ __pyx_t_1 = ((__pyx_v_x > 0.0) != 0); if (__pyx_t_1) { /* "regions/_geometry/core.pyx":53 * """ * if x > 0: * return sqrt(x) # <<<<<<<<<<<<<< * else: * return 0 */ __pyx_r = sqrt(__pyx_v_x); goto __pyx_L0; /* "regions/_geometry/core.pyx":52 * to be positive on paper. * """ * if x > 0: # <<<<<<<<<<<<<< * return sqrt(x) * else: */ } /* "regions/_geometry/core.pyx":55 * return sqrt(x) * else: * return 0 # <<<<<<<<<<<<<< * * # NOTE: The following two functions use cdef because they are not intended to be */ /*else*/ { __pyx_r = 0.0; goto __pyx_L0; } /* "regions/_geometry/core.pyx":41 * * * cdef double floor_sqrt(double x): # <<<<<<<<<<<<<< * """ * In some of the geometrical functions, we have to take the sqrt of a number */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/core.pyx":63 * * * cdef double distance(double x1, double y1, double x2, double y2): # <<<<<<<<<<<<<< * """ * Distance between two points in two dimensions. */ static double __pyx_f_7regions_9_geometry_4core_distance(double __pyx_v_x1, double __pyx_v_y1, double __pyx_v_x2, double __pyx_v_y2) { double __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("distance", 0); /* "regions/_geometry/core.pyx":80 * """ * * return sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) # <<<<<<<<<<<<<< * * */ __pyx_r = sqrt((pow((__pyx_v_x2 - __pyx_v_x1), 2.0) + pow((__pyx_v_y2 - __pyx_v_y1), 2.0))); goto __pyx_L0; /* "regions/_geometry/core.pyx":63 * * * cdef double distance(double x1, double y1, double x2, double y2): # <<<<<<<<<<<<<< * """ * Distance between two points in two dimensions. */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/core.pyx":83 * * * cdef double area_arc(double x1, double y1, double x2, double y2, double r): # <<<<<<<<<<<<<< * """ * Area of a circle arc with radius r between points (x1, y1) and (x2, y2). */ static double __pyx_f_7regions_9_geometry_4core_area_arc(double __pyx_v_x1, double __pyx_v_y1, double __pyx_v_x2, double __pyx_v_y2, double __pyx_v_r) { double __pyx_v_a; double __pyx_v_theta; double __pyx_r; __Pyx_RefNannyDeclarations double __pyx_t_1; __Pyx_RefNannySetupContext("area_arc", 0); /* "regions/_geometry/core.pyx":93 * * cdef double a, theta * a = distance(x1, y1, x2, y2) # <<<<<<<<<<<<<< * theta = 2. * asin(0.5 * a / r) * return 0.5 * r * r * (theta - sin(theta)) */ __pyx_v_a = __pyx_f_7regions_9_geometry_4core_distance(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2); /* "regions/_geometry/core.pyx":94 * cdef double a, theta * a = distance(x1, y1, x2, y2) * theta = 2. * asin(0.5 * a / r) # <<<<<<<<<<<<<< * return 0.5 * r * r * (theta - sin(theta)) * */ __pyx_t_1 = (0.5 * __pyx_v_a); if (unlikely(__pyx_v_r == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 94, __pyx_L1_error) } __pyx_v_theta = (2. * asin((__pyx_t_1 / __pyx_v_r))); /* "regions/_geometry/core.pyx":95 * a = distance(x1, y1, x2, y2) * theta = 2. * asin(0.5 * a / r) * return 0.5 * r * r * (theta - sin(theta)) # <<<<<<<<<<<<<< * * */ __pyx_r = (((0.5 * __pyx_v_r) * __pyx_v_r) * (__pyx_v_theta - sin(__pyx_v_theta))); goto __pyx_L0; /* "regions/_geometry/core.pyx":83 * * * cdef double area_arc(double x1, double y1, double x2, double y2, double r): # <<<<<<<<<<<<<< * """ * Area of a circle arc with radius r between points (x1, y1) and (x2, y2). */ /* function exit code */ __pyx_L1_error:; __Pyx_WriteUnraisable("regions._geometry.core.area_arc", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/core.pyx":98 * * * cdef double area_triangle(double x1, double y1, double x2, double y2, double x3, # <<<<<<<<<<<<<< * double y3): * """ */ static double __pyx_f_7regions_9_geometry_4core_area_triangle(double __pyx_v_x1, double __pyx_v_y1, double __pyx_v_x2, double __pyx_v_y2, double __pyx_v_x3, double __pyx_v_y3) { double __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("area_triangle", 0); /* "regions/_geometry/core.pyx":103 * Area of a triangle defined by three vertices. * """ * return 0.5 * abs(x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) # <<<<<<<<<<<<<< * * */ __pyx_r = (0.5 * fabs((((__pyx_v_x1 * (__pyx_v_y2 - __pyx_v_y3)) + (__pyx_v_x2 * (__pyx_v_y3 - __pyx_v_y1))) + (__pyx_v_x3 * (__pyx_v_y1 - __pyx_v_y2))))); goto __pyx_L0; /* "regions/_geometry/core.pyx":98 * * * cdef double area_triangle(double x1, double y1, double x2, double y2, double x3, # <<<<<<<<<<<<<< * double y3): * """ */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/core.pyx":106 * * * cdef double area_arc_unit(double x1, double y1, double x2, double y2): # <<<<<<<<<<<<<< * """ * Area of a circle arc with radius R between points (x1, y1) and (x2, y2) */ static double __pyx_f_7regions_9_geometry_4core_area_arc_unit(double __pyx_v_x1, double __pyx_v_y1, double __pyx_v_x2, double __pyx_v_y2) { double __pyx_v_a; double __pyx_v_theta; double __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("area_arc_unit", 0); /* "regions/_geometry/core.pyx":115 * """ * cdef double a, theta * a = distance(x1, y1, x2, y2) # <<<<<<<<<<<<<< * theta = 2. * asin(0.5 * a) * return 0.5 * (theta - sin(theta)) */ __pyx_v_a = __pyx_f_7regions_9_geometry_4core_distance(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2); /* "regions/_geometry/core.pyx":116 * cdef double a, theta * a = distance(x1, y1, x2, y2) * theta = 2. * asin(0.5 * a) # <<<<<<<<<<<<<< * return 0.5 * (theta - sin(theta)) * */ __pyx_v_theta = (2. * asin((0.5 * __pyx_v_a))); /* "regions/_geometry/core.pyx":117 * a = distance(x1, y1, x2, y2) * theta = 2. * asin(0.5 * a) * return 0.5 * (theta - sin(theta)) # <<<<<<<<<<<<<< * * */ __pyx_r = (0.5 * (__pyx_v_theta - sin(__pyx_v_theta))); goto __pyx_L0; /* "regions/_geometry/core.pyx":106 * * * cdef double area_arc_unit(double x1, double y1, double x2, double y2): # <<<<<<<<<<<<<< * """ * Area of a circle arc with radius R between points (x1, y1) and (x2, y2) */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/core.pyx":120 * * * cdef int in_triangle(double x, double y, double x1, double y1, double x2, double y2, double x3, double y3): # <<<<<<<<<<<<<< * """ * Check if a point (x,y) is inside a triangle */ static int __pyx_f_7regions_9_geometry_4core_in_triangle(double __pyx_v_x, double __pyx_v_y, double __pyx_v_x1, double __pyx_v_y1, double __pyx_v_x2, double __pyx_v_y2, double __pyx_v_x3, double __pyx_v_y3) { int __pyx_v_c; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; double __pyx_t_3; double __pyx_t_4; __Pyx_RefNannySetupContext("in_triangle", 0); /* "regions/_geometry/core.pyx":124 * Check if a point (x,y) is inside a triangle * """ * cdef int c = 0 # <<<<<<<<<<<<<< * * c += ((y1 > y) != (y2 > y) and x < (x2 - x1) * (y - y1) / (y2 - y1) + x1) */ __pyx_v_c = 0; /* "regions/_geometry/core.pyx":126 * cdef int c = 0 * * c += ((y1 > y) != (y2 > y) and x < (x2 - x1) * (y - y1) / (y2 - y1) + x1) # <<<<<<<<<<<<<< * c += ((y2 > y) != (y3 > y) and x < (x3 - x2) * (y - y2) / (y3 - y2) + x2) * c += ((y3 > y) != (y1 > y) and x < (x1 - x3) * (y - y3) / (y1 - y3) + x3) */ __pyx_t_2 = ((__pyx_v_y1 > __pyx_v_y) != (__pyx_v_y2 > __pyx_v_y)); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L3_bool_binop_done; } __pyx_t_3 = ((__pyx_v_x2 - __pyx_v_x1) * (__pyx_v_y - __pyx_v_y1)); __pyx_t_4 = (__pyx_v_y2 - __pyx_v_y1); if (unlikely(__pyx_t_4 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 126, __pyx_L1_error) } __pyx_t_2 = (__pyx_v_x < ((__pyx_t_3 / __pyx_t_4) + __pyx_v_x1)); __pyx_t_1 = __pyx_t_2; __pyx_L3_bool_binop_done:; __pyx_v_c = (__pyx_v_c + __pyx_t_1); /* "regions/_geometry/core.pyx":127 * * c += ((y1 > y) != (y2 > y) and x < (x2 - x1) * (y - y1) / (y2 - y1) + x1) * c += ((y2 > y) != (y3 > y) and x < (x3 - x2) * (y - y2) / (y3 - y2) + x2) # <<<<<<<<<<<<<< * c += ((y3 > y) != (y1 > y) and x < (x1 - x3) * (y - y3) / (y1 - y3) + x3) * */ __pyx_t_2 = ((__pyx_v_y2 > __pyx_v_y) != (__pyx_v_y3 > __pyx_v_y)); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L5_bool_binop_done; } __pyx_t_4 = ((__pyx_v_x3 - __pyx_v_x2) * (__pyx_v_y - __pyx_v_y2)); __pyx_t_3 = (__pyx_v_y3 - __pyx_v_y2); if (unlikely(__pyx_t_3 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 127, __pyx_L1_error) } __pyx_t_2 = (__pyx_v_x < ((__pyx_t_4 / __pyx_t_3) + __pyx_v_x2)); __pyx_t_1 = __pyx_t_2; __pyx_L5_bool_binop_done:; __pyx_v_c = (__pyx_v_c + __pyx_t_1); /* "regions/_geometry/core.pyx":128 * c += ((y1 > y) != (y2 > y) and x < (x2 - x1) * (y - y1) / (y2 - y1) + x1) * c += ((y2 > y) != (y3 > y) and x < (x3 - x2) * (y - y2) / (y3 - y2) + x2) * c += ((y3 > y) != (y1 > y) and x < (x1 - x3) * (y - y3) / (y1 - y3) + x3) # <<<<<<<<<<<<<< * * return c % 2 == 1 */ __pyx_t_2 = ((__pyx_v_y3 > __pyx_v_y) != (__pyx_v_y1 > __pyx_v_y)); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L7_bool_binop_done; } __pyx_t_3 = ((__pyx_v_x1 - __pyx_v_x3) * (__pyx_v_y - __pyx_v_y3)); __pyx_t_4 = (__pyx_v_y1 - __pyx_v_y3); if (unlikely(__pyx_t_4 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 128, __pyx_L1_error) } __pyx_t_2 = (__pyx_v_x < ((__pyx_t_3 / __pyx_t_4) + __pyx_v_x3)); __pyx_t_1 = __pyx_t_2; __pyx_L7_bool_binop_done:; __pyx_v_c = (__pyx_v_c + __pyx_t_1); /* "regions/_geometry/core.pyx":130 * c += ((y3 > y) != (y1 > y) and x < (x1 - x3) * (y - y3) / (y1 - y3) + x3) * * return c % 2 == 1 # <<<<<<<<<<<<<< * * */ __pyx_r = (__Pyx_mod_long(__pyx_v_c, 2) == 1); goto __pyx_L0; /* "regions/_geometry/core.pyx":120 * * * cdef int in_triangle(double x, double y, double x1, double y1, double x2, double y2, double x3, double y3): # <<<<<<<<<<<<<< * """ * Check if a point (x,y) is inside a triangle */ /* function exit code */ __pyx_L1_error:; __Pyx_WriteUnraisable("regions._geometry.core.in_triangle", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/core.pyx":133 * * * cdef intersections circle_line(double x1, double y1, double x2, double y2): # <<<<<<<<<<<<<< * """Intersection of a line defined by two points with a unit circle""" * */ static __pyx_t_7regions_9_geometry_4core_intersections __pyx_f_7regions_9_geometry_4core_circle_line(double __pyx_v_x1, double __pyx_v_y1, double __pyx_v_x2, double __pyx_v_y2) { double __pyx_v_a; double __pyx_v_b; double __pyx_v_delta; double __pyx_v_dx; double __pyx_v_dy; double __pyx_v_tolerance; __pyx_t_7regions_9_geometry_4core_intersections __pyx_v_inter; __pyx_t_7regions_9_geometry_4core_intersections __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; double __pyx_t_3; double __pyx_t_4; __Pyx_RefNannySetupContext("circle_line", 0); /* "regions/_geometry/core.pyx":137 * * cdef double a, b, delta, dx, dy * cdef double tolerance = 1.e-10 # <<<<<<<<<<<<<< * cdef intersections inter * */ __pyx_v_tolerance = 1.e-10; /* "regions/_geometry/core.pyx":140 * cdef intersections inter * * dx = x2 - x1 # <<<<<<<<<<<<<< * dy = y2 - y1 * */ __pyx_v_dx = (__pyx_v_x2 - __pyx_v_x1); /* "regions/_geometry/core.pyx":141 * * dx = x2 - x1 * dy = y2 - y1 # <<<<<<<<<<<<<< * * if fabs(dx) < tolerance and fabs(dy) < tolerance: */ __pyx_v_dy = (__pyx_v_y2 - __pyx_v_y1); /* "regions/_geometry/core.pyx":143 * dy = y2 - y1 * * if fabs(dx) < tolerance and fabs(dy) < tolerance: # <<<<<<<<<<<<<< * inter.p1.x = 2. * inter.p1.y = 2. */ __pyx_t_2 = ((fabs(__pyx_v_dx) < __pyx_v_tolerance) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = ((fabs(__pyx_v_dy) < __pyx_v_tolerance) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "regions/_geometry/core.pyx":144 * * if fabs(dx) < tolerance and fabs(dy) < tolerance: * inter.p1.x = 2. # <<<<<<<<<<<<<< * inter.p1.y = 2. * inter.p2.x = 2. */ __pyx_v_inter.p1.x = 2.; /* "regions/_geometry/core.pyx":145 * if fabs(dx) < tolerance and fabs(dy) < tolerance: * inter.p1.x = 2. * inter.p1.y = 2. # <<<<<<<<<<<<<< * inter.p2.x = 2. * inter.p2.y = 2. */ __pyx_v_inter.p1.y = 2.; /* "regions/_geometry/core.pyx":146 * inter.p1.x = 2. * inter.p1.y = 2. * inter.p2.x = 2. # <<<<<<<<<<<<<< * inter.p2.y = 2. * */ __pyx_v_inter.p2.x = 2.; /* "regions/_geometry/core.pyx":147 * inter.p1.y = 2. * inter.p2.x = 2. * inter.p2.y = 2. # <<<<<<<<<<<<<< * * elif fabs(dx) > fabs(dy): */ __pyx_v_inter.p2.y = 2.; /* "regions/_geometry/core.pyx":143 * dy = y2 - y1 * * if fabs(dx) < tolerance and fabs(dy) < tolerance: # <<<<<<<<<<<<<< * inter.p1.x = 2. * inter.p1.y = 2. */ goto __pyx_L3; } /* "regions/_geometry/core.pyx":149 * inter.p2.y = 2. * * elif fabs(dx) > fabs(dy): # <<<<<<<<<<<<<< * * # Find the slope and intercept of the line */ __pyx_t_1 = ((fabs(__pyx_v_dx) > fabs(__pyx_v_dy)) != 0); if (__pyx_t_1) { /* "regions/_geometry/core.pyx":152 * * # Find the slope and intercept of the line * a = dy / dx # <<<<<<<<<<<<<< * b = y1 - a * x1 * */ if (unlikely(__pyx_v_dx == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 152, __pyx_L1_error) } __pyx_v_a = (__pyx_v_dy / __pyx_v_dx); /* "regions/_geometry/core.pyx":153 * # Find the slope and intercept of the line * a = dy / dx * b = y1 - a * x1 # <<<<<<<<<<<<<< * * # Find the determinant of the quadratic equation */ __pyx_v_b = (__pyx_v_y1 - (__pyx_v_a * __pyx_v_x1)); /* "regions/_geometry/core.pyx":156 * * # Find the determinant of the quadratic equation * delta = 1. + a * a - b * b # <<<<<<<<<<<<<< * if delta > 0.: # solutions exist * */ __pyx_v_delta = ((1. + (__pyx_v_a * __pyx_v_a)) - (__pyx_v_b * __pyx_v_b)); /* "regions/_geometry/core.pyx":157 * # Find the determinant of the quadratic equation * delta = 1. + a * a - b * b * if delta > 0.: # solutions exist # <<<<<<<<<<<<<< * * delta = sqrt(delta) */ __pyx_t_1 = ((__pyx_v_delta > 0.) != 0); if (__pyx_t_1) { /* "regions/_geometry/core.pyx":159 * if delta > 0.: # solutions exist * * delta = sqrt(delta) # <<<<<<<<<<<<<< * * inter.p1.x = (- a * b - delta) / (1. + a * a) */ __pyx_v_delta = sqrt(__pyx_v_delta); /* "regions/_geometry/core.pyx":161 * delta = sqrt(delta) * * inter.p1.x = (- a * b - delta) / (1. + a * a) # <<<<<<<<<<<<<< * inter.p1.y = a * inter.p1.x + b * inter.p2.x = (- a * b + delta) / (1. + a * a) */ __pyx_t_3 = (((-__pyx_v_a) * __pyx_v_b) - __pyx_v_delta); __pyx_t_4 = (1. + (__pyx_v_a * __pyx_v_a)); if (unlikely(__pyx_t_4 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 161, __pyx_L1_error) } __pyx_v_inter.p1.x = (__pyx_t_3 / __pyx_t_4); /* "regions/_geometry/core.pyx":162 * * inter.p1.x = (- a * b - delta) / (1. + a * a) * inter.p1.y = a * inter.p1.x + b # <<<<<<<<<<<<<< * inter.p2.x = (- a * b + delta) / (1. + a * a) * inter.p2.y = a * inter.p2.x + b */ __pyx_v_inter.p1.y = ((__pyx_v_a * __pyx_v_inter.p1.x) + __pyx_v_b); /* "regions/_geometry/core.pyx":163 * inter.p1.x = (- a * b - delta) / (1. + a * a) * inter.p1.y = a * inter.p1.x + b * inter.p2.x = (- a * b + delta) / (1. + a * a) # <<<<<<<<<<<<<< * inter.p2.y = a * inter.p2.x + b * */ __pyx_t_4 = (((-__pyx_v_a) * __pyx_v_b) + __pyx_v_delta); __pyx_t_3 = (1. + (__pyx_v_a * __pyx_v_a)); if (unlikely(__pyx_t_3 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 163, __pyx_L1_error) } __pyx_v_inter.p2.x = (__pyx_t_4 / __pyx_t_3); /* "regions/_geometry/core.pyx":164 * inter.p1.y = a * inter.p1.x + b * inter.p2.x = (- a * b + delta) / (1. + a * a) * inter.p2.y = a * inter.p2.x + b # <<<<<<<<<<<<<< * * else: # no solution, return values > 1 */ __pyx_v_inter.p2.y = ((__pyx_v_a * __pyx_v_inter.p2.x) + __pyx_v_b); /* "regions/_geometry/core.pyx":157 * # Find the determinant of the quadratic equation * delta = 1. + a * a - b * b * if delta > 0.: # solutions exist # <<<<<<<<<<<<<< * * delta = sqrt(delta) */ goto __pyx_L6; } /* "regions/_geometry/core.pyx":167 * * else: # no solution, return values > 1 * inter.p1.x = 2. # <<<<<<<<<<<<<< * inter.p1.y = 2. * inter.p2.x = 2. */ /*else*/ { __pyx_v_inter.p1.x = 2.; /* "regions/_geometry/core.pyx":168 * else: # no solution, return values > 1 * inter.p1.x = 2. * inter.p1.y = 2. # <<<<<<<<<<<<<< * inter.p2.x = 2. * inter.p2.y = 2. */ __pyx_v_inter.p1.y = 2.; /* "regions/_geometry/core.pyx":169 * inter.p1.x = 2. * inter.p1.y = 2. * inter.p2.x = 2. # <<<<<<<<<<<<<< * inter.p2.y = 2. * */ __pyx_v_inter.p2.x = 2.; /* "regions/_geometry/core.pyx":170 * inter.p1.y = 2. * inter.p2.x = 2. * inter.p2.y = 2. # <<<<<<<<<<<<<< * * else: */ __pyx_v_inter.p2.y = 2.; } __pyx_L6:; /* "regions/_geometry/core.pyx":149 * inter.p2.y = 2. * * elif fabs(dx) > fabs(dy): # <<<<<<<<<<<<<< * * # Find the slope and intercept of the line */ goto __pyx_L3; } /* "regions/_geometry/core.pyx":175 * * # Find the slope and intercept of the line * a = dx / dy # <<<<<<<<<<<<<< * b = x1 - a * y1 * */ /*else*/ { if (unlikely(__pyx_v_dy == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 175, __pyx_L1_error) } __pyx_v_a = (__pyx_v_dx / __pyx_v_dy); /* "regions/_geometry/core.pyx":176 * # Find the slope and intercept of the line * a = dx / dy * b = x1 - a * y1 # <<<<<<<<<<<<<< * * # Find the determinant of the quadratic equation */ __pyx_v_b = (__pyx_v_x1 - (__pyx_v_a * __pyx_v_y1)); /* "regions/_geometry/core.pyx":179 * * # Find the determinant of the quadratic equation * delta = 1. + a * a - b * b # <<<<<<<<<<<<<< * * if delta > 0.: # solutions exist */ __pyx_v_delta = ((1. + (__pyx_v_a * __pyx_v_a)) - (__pyx_v_b * __pyx_v_b)); /* "regions/_geometry/core.pyx":181 * delta = 1. + a * a - b * b * * if delta > 0.: # solutions exist # <<<<<<<<<<<<<< * * delta = sqrt(delta) */ __pyx_t_1 = ((__pyx_v_delta > 0.) != 0); if (__pyx_t_1) { /* "regions/_geometry/core.pyx":183 * if delta > 0.: # solutions exist * * delta = sqrt(delta) # <<<<<<<<<<<<<< * * inter.p1.y = (- a * b - delta) / (1. + a * a) */ __pyx_v_delta = sqrt(__pyx_v_delta); /* "regions/_geometry/core.pyx":185 * delta = sqrt(delta) * * inter.p1.y = (- a * b - delta) / (1. + a * a) # <<<<<<<<<<<<<< * inter.p1.x = a * inter.p1.y + b * inter.p2.y = (- a * b + delta) / (1. + a * a) */ __pyx_t_3 = (((-__pyx_v_a) * __pyx_v_b) - __pyx_v_delta); __pyx_t_4 = (1. + (__pyx_v_a * __pyx_v_a)); if (unlikely(__pyx_t_4 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 185, __pyx_L1_error) } __pyx_v_inter.p1.y = (__pyx_t_3 / __pyx_t_4); /* "regions/_geometry/core.pyx":186 * * inter.p1.y = (- a * b - delta) / (1. + a * a) * inter.p1.x = a * inter.p1.y + b # <<<<<<<<<<<<<< * inter.p2.y = (- a * b + delta) / (1. + a * a) * inter.p2.x = a * inter.p2.y + b */ __pyx_v_inter.p1.x = ((__pyx_v_a * __pyx_v_inter.p1.y) + __pyx_v_b); /* "regions/_geometry/core.pyx":187 * inter.p1.y = (- a * b - delta) / (1. + a * a) * inter.p1.x = a * inter.p1.y + b * inter.p2.y = (- a * b + delta) / (1. + a * a) # <<<<<<<<<<<<<< * inter.p2.x = a * inter.p2.y + b * */ __pyx_t_4 = (((-__pyx_v_a) * __pyx_v_b) + __pyx_v_delta); __pyx_t_3 = (1. + (__pyx_v_a * __pyx_v_a)); if (unlikely(__pyx_t_3 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 187, __pyx_L1_error) } __pyx_v_inter.p2.y = (__pyx_t_4 / __pyx_t_3); /* "regions/_geometry/core.pyx":188 * inter.p1.x = a * inter.p1.y + b * inter.p2.y = (- a * b + delta) / (1. + a * a) * inter.p2.x = a * inter.p2.y + b # <<<<<<<<<<<<<< * * else: # no solution, return values > 1 */ __pyx_v_inter.p2.x = ((__pyx_v_a * __pyx_v_inter.p2.y) + __pyx_v_b); /* "regions/_geometry/core.pyx":181 * delta = 1. + a * a - b * b * * if delta > 0.: # solutions exist # <<<<<<<<<<<<<< * * delta = sqrt(delta) */ goto __pyx_L7; } /* "regions/_geometry/core.pyx":191 * * else: # no solution, return values > 1 * inter.p1.x = 2. # <<<<<<<<<<<<<< * inter.p1.y = 2. * inter.p2.x = 2. */ /*else*/ { __pyx_v_inter.p1.x = 2.; /* "regions/_geometry/core.pyx":192 * else: # no solution, return values > 1 * inter.p1.x = 2. * inter.p1.y = 2. # <<<<<<<<<<<<<< * inter.p2.x = 2. * inter.p2.y = 2. */ __pyx_v_inter.p1.y = 2.; /* "regions/_geometry/core.pyx":193 * inter.p1.x = 2. * inter.p1.y = 2. * inter.p2.x = 2. # <<<<<<<<<<<<<< * inter.p2.y = 2. * */ __pyx_v_inter.p2.x = 2.; /* "regions/_geometry/core.pyx":194 * inter.p1.y = 2. * inter.p2.x = 2. * inter.p2.y = 2. # <<<<<<<<<<<<<< * * return inter */ __pyx_v_inter.p2.y = 2.; } __pyx_L7:; } __pyx_L3:; /* "regions/_geometry/core.pyx":196 * inter.p2.y = 2. * * return inter # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_inter; goto __pyx_L0; /* "regions/_geometry/core.pyx":133 * * * cdef intersections circle_line(double x1, double y1, double x2, double y2): # <<<<<<<<<<<<<< * """Intersection of a line defined by two points with a unit circle""" * */ /* function exit code */ __pyx_L1_error:; __Pyx_WriteUnraisable("regions._geometry.core.circle_line", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/core.pyx":199 * * * cdef point circle_segment_single2(double x1, double y1, double x2, double y2): # <<<<<<<<<<<<<< * """ * The intersection of a line with the unit circle. The intersection the */ static __pyx_t_7regions_9_geometry_4core_point __pyx_f_7regions_9_geometry_4core_circle_segment_single2(double __pyx_v_x1, double __pyx_v_y1, double __pyx_v_x2, double __pyx_v_y2) { double __pyx_v_dx1; double __pyx_v_dy1; double __pyx_v_dx2; double __pyx_v_dy2; __pyx_t_7regions_9_geometry_4core_intersections __pyx_v_inter; __pyx_t_7regions_9_geometry_4core_point __pyx_v_pt1; __pyx_t_7regions_9_geometry_4core_point __pyx_v_pt2; __pyx_t_7regions_9_geometry_4core_point __pyx_v_pt; __pyx_t_7regions_9_geometry_4core_point __pyx_r; __Pyx_RefNannyDeclarations __pyx_t_7regions_9_geometry_4core_point __pyx_t_1; int __pyx_t_2; __Pyx_RefNannySetupContext("circle_segment_single2", 0); /* "regions/_geometry/core.pyx":209 * cdef point pt1, pt2, pt * * inter = circle_line(x1, y1, x2, y2) # <<<<<<<<<<<<<< * * pt1 = inter.p1 */ __pyx_v_inter = __pyx_f_7regions_9_geometry_4core_circle_line(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2); /* "regions/_geometry/core.pyx":211 * inter = circle_line(x1, y1, x2, y2) * * pt1 = inter.p1 # <<<<<<<<<<<<<< * pt2 = inter.p2 * */ __pyx_t_1 = __pyx_v_inter.p1; __pyx_v_pt1 = __pyx_t_1; /* "regions/_geometry/core.pyx":212 * * pt1 = inter.p1 * pt2 = inter.p2 # <<<<<<<<<<<<<< * * # Can be optimized, but just checking for correctness right now */ __pyx_t_1 = __pyx_v_inter.p2; __pyx_v_pt2 = __pyx_t_1; /* "regions/_geometry/core.pyx":215 * * # Can be optimized, but just checking for correctness right now * dx1 = fabs(pt1.x - x2) # <<<<<<<<<<<<<< * dy1 = fabs(pt1.y - y2) * dx2 = fabs(pt2.x - x2) */ __pyx_v_dx1 = fabs((__pyx_v_pt1.x - __pyx_v_x2)); /* "regions/_geometry/core.pyx":216 * # Can be optimized, but just checking for correctness right now * dx1 = fabs(pt1.x - x2) * dy1 = fabs(pt1.y - y2) # <<<<<<<<<<<<<< * dx2 = fabs(pt2.x - x2) * dy2 = fabs(pt2.y - y2) */ __pyx_v_dy1 = fabs((__pyx_v_pt1.y - __pyx_v_y2)); /* "regions/_geometry/core.pyx":217 * dx1 = fabs(pt1.x - x2) * dy1 = fabs(pt1.y - y2) * dx2 = fabs(pt2.x - x2) # <<<<<<<<<<<<<< * dy2 = fabs(pt2.y - y2) * */ __pyx_v_dx2 = fabs((__pyx_v_pt2.x - __pyx_v_x2)); /* "regions/_geometry/core.pyx":218 * dy1 = fabs(pt1.y - y2) * dx2 = fabs(pt2.x - x2) * dy2 = fabs(pt2.y - y2) # <<<<<<<<<<<<<< * * if dx1 > dy1: # compare based on x-axis */ __pyx_v_dy2 = fabs((__pyx_v_pt2.y - __pyx_v_y2)); /* "regions/_geometry/core.pyx":220 * dy2 = fabs(pt2.y - y2) * * if dx1 > dy1: # compare based on x-axis # <<<<<<<<<<<<<< * if dx1 > dx2: * pt = pt2 */ __pyx_t_2 = ((__pyx_v_dx1 > __pyx_v_dy1) != 0); if (__pyx_t_2) { /* "regions/_geometry/core.pyx":221 * * if dx1 > dy1: # compare based on x-axis * if dx1 > dx2: # <<<<<<<<<<<<<< * pt = pt2 * else: */ __pyx_t_2 = ((__pyx_v_dx1 > __pyx_v_dx2) != 0); if (__pyx_t_2) { /* "regions/_geometry/core.pyx":222 * if dx1 > dy1: # compare based on x-axis * if dx1 > dx2: * pt = pt2 # <<<<<<<<<<<<<< * else: * pt = pt1 */ __pyx_v_pt = __pyx_v_pt2; /* "regions/_geometry/core.pyx":221 * * if dx1 > dy1: # compare based on x-axis * if dx1 > dx2: # <<<<<<<<<<<<<< * pt = pt2 * else: */ goto __pyx_L4; } /* "regions/_geometry/core.pyx":224 * pt = pt2 * else: * pt = pt1 # <<<<<<<<<<<<<< * else: * if dy1 > dy2: */ /*else*/ { __pyx_v_pt = __pyx_v_pt1; } __pyx_L4:; /* "regions/_geometry/core.pyx":220 * dy2 = fabs(pt2.y - y2) * * if dx1 > dy1: # compare based on x-axis # <<<<<<<<<<<<<< * if dx1 > dx2: * pt = pt2 */ goto __pyx_L3; } /* "regions/_geometry/core.pyx":226 * pt = pt1 * else: * if dy1 > dy2: # <<<<<<<<<<<<<< * pt = pt2 * else: */ /*else*/ { __pyx_t_2 = ((__pyx_v_dy1 > __pyx_v_dy2) != 0); if (__pyx_t_2) { /* "regions/_geometry/core.pyx":227 * else: * if dy1 > dy2: * pt = pt2 # <<<<<<<<<<<<<< * else: * pt = pt1 */ __pyx_v_pt = __pyx_v_pt2; /* "regions/_geometry/core.pyx":226 * pt = pt1 * else: * if dy1 > dy2: # <<<<<<<<<<<<<< * pt = pt2 * else: */ goto __pyx_L5; } /* "regions/_geometry/core.pyx":229 * pt = pt2 * else: * pt = pt1 # <<<<<<<<<<<<<< * * return pt */ /*else*/ { __pyx_v_pt = __pyx_v_pt1; } __pyx_L5:; } __pyx_L3:; /* "regions/_geometry/core.pyx":231 * pt = pt1 * * return pt # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_pt; goto __pyx_L0; /* "regions/_geometry/core.pyx":199 * * * cdef point circle_segment_single2(double x1, double y1, double x2, double y2): # <<<<<<<<<<<<<< * """ * The intersection of a line with the unit circle. The intersection the */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/core.pyx":234 * * * cdef intersections circle_segment(double x1, double y1, double x2, double y2): # <<<<<<<<<<<<<< * """ * Intersection(s) of a segment with the unit circle. Discard any */ static __pyx_t_7regions_9_geometry_4core_intersections __pyx_f_7regions_9_geometry_4core_circle_segment(double __pyx_v_x1, double __pyx_v_y1, double __pyx_v_x2, double __pyx_v_y2) { __pyx_t_7regions_9_geometry_4core_intersections __pyx_v_inter; __pyx_t_7regions_9_geometry_4core_intersections __pyx_v_inter_new; __pyx_t_7regions_9_geometry_4core_point __pyx_v_pt1; __pyx_t_7regions_9_geometry_4core_point __pyx_v_pt2; __pyx_t_7regions_9_geometry_4core_intersections __pyx_r; __Pyx_RefNannyDeclarations __pyx_t_7regions_9_geometry_4core_point __pyx_t_1; int __pyx_t_2; int __pyx_t_3; double __pyx_t_4; double __pyx_t_5; __Pyx_RefNannySetupContext("circle_segment", 0); /* "regions/_geometry/core.pyx":243 * cdef point pt1, pt2 * * inter = circle_line(x1, y1, x2, y2) # <<<<<<<<<<<<<< * * pt1 = inter.p1 */ __pyx_v_inter = __pyx_f_7regions_9_geometry_4core_circle_line(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2); /* "regions/_geometry/core.pyx":245 * inter = circle_line(x1, y1, x2, y2) * * pt1 = inter.p1 # <<<<<<<<<<<<<< * pt2 = inter.p2 * */ __pyx_t_1 = __pyx_v_inter.p1; __pyx_v_pt1 = __pyx_t_1; /* "regions/_geometry/core.pyx":246 * * pt1 = inter.p1 * pt2 = inter.p2 # <<<<<<<<<<<<<< * * if (pt1.x > x1 and pt1.x > x2) or (pt1.x < x1 and pt1.x < x2) or (pt1.y > y1 and pt1.y > y2) or (pt1.y < y1 and pt1.y < y2): */ __pyx_t_1 = __pyx_v_inter.p2; __pyx_v_pt2 = __pyx_t_1; /* "regions/_geometry/core.pyx":248 * pt2 = inter.p2 * * if (pt1.x > x1 and pt1.x > x2) or (pt1.x < x1 and pt1.x < x2) or (pt1.y > y1 and pt1.y > y2) or (pt1.y < y1 and pt1.y < y2): # <<<<<<<<<<<<<< * pt1.x, pt1.y = 2., 2. * if (pt2.x > x1 and pt2.x > x2) or (pt2.x < x1 and pt2.x < x2) or (pt2.y > y1 and pt2.y > y2) or (pt2.y < y1 and pt2.y < y2): */ __pyx_t_3 = ((__pyx_v_pt1.x > __pyx_v_x1) != 0); if (!__pyx_t_3) { goto __pyx_L5_next_or; } else { } __pyx_t_3 = ((__pyx_v_pt1.x > __pyx_v_x2) != 0); if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_L5_next_or:; __pyx_t_3 = ((__pyx_v_pt1.x < __pyx_v_x1) != 0); if (!__pyx_t_3) { goto __pyx_L7_next_or; } else { } __pyx_t_3 = ((__pyx_v_pt1.x < __pyx_v_x2) != 0); if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_L7_next_or:; __pyx_t_3 = ((__pyx_v_pt1.y > __pyx_v_y1) != 0); if (!__pyx_t_3) { goto __pyx_L9_next_or; } else { } __pyx_t_3 = ((__pyx_v_pt1.y > __pyx_v_y2) != 0); if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_L9_next_or:; __pyx_t_3 = ((__pyx_v_pt1.y < __pyx_v_y1) != 0); if (__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_t_3 = ((__pyx_v_pt1.y < __pyx_v_y2) != 0); __pyx_t_2 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { /* "regions/_geometry/core.pyx":249 * * if (pt1.x > x1 and pt1.x > x2) or (pt1.x < x1 and pt1.x < x2) or (pt1.y > y1 and pt1.y > y2) or (pt1.y < y1 and pt1.y < y2): * pt1.x, pt1.y = 2., 2. # <<<<<<<<<<<<<< * if (pt2.x > x1 and pt2.x > x2) or (pt2.x < x1 and pt2.x < x2) or (pt2.y > y1 and pt2.y > y2) or (pt2.y < y1 and pt2.y < y2): * pt2.x, pt2.y = 2., 2. */ __pyx_t_4 = 2.; __pyx_t_5 = 2.; __pyx_v_pt1.x = __pyx_t_4; __pyx_v_pt1.y = __pyx_t_5; /* "regions/_geometry/core.pyx":248 * pt2 = inter.p2 * * if (pt1.x > x1 and pt1.x > x2) or (pt1.x < x1 and pt1.x < x2) or (pt1.y > y1 and pt1.y > y2) or (pt1.y < y1 and pt1.y < y2): # <<<<<<<<<<<<<< * pt1.x, pt1.y = 2., 2. * if (pt2.x > x1 and pt2.x > x2) or (pt2.x < x1 and pt2.x < x2) or (pt2.y > y1 and pt2.y > y2) or (pt2.y < y1 and pt2.y < y2): */ } /* "regions/_geometry/core.pyx":250 * if (pt1.x > x1 and pt1.x > x2) or (pt1.x < x1 and pt1.x < x2) or (pt1.y > y1 and pt1.y > y2) or (pt1.y < y1 and pt1.y < y2): * pt1.x, pt1.y = 2., 2. * if (pt2.x > x1 and pt2.x > x2) or (pt2.x < x1 and pt2.x < x2) or (pt2.y > y1 and pt2.y > y2) or (pt2.y < y1 and pt2.y < y2): # <<<<<<<<<<<<<< * pt2.x, pt2.y = 2., 2. * */ __pyx_t_3 = ((__pyx_v_pt2.x > __pyx_v_x1) != 0); if (!__pyx_t_3) { goto __pyx_L14_next_or; } else { } __pyx_t_3 = ((__pyx_v_pt2.x > __pyx_v_x2) != 0); if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L13_bool_binop_done; } __pyx_L14_next_or:; __pyx_t_3 = ((__pyx_v_pt2.x < __pyx_v_x1) != 0); if (!__pyx_t_3) { goto __pyx_L16_next_or; } else { } __pyx_t_3 = ((__pyx_v_pt2.x < __pyx_v_x2) != 0); if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L13_bool_binop_done; } __pyx_L16_next_or:; __pyx_t_3 = ((__pyx_v_pt2.y > __pyx_v_y1) != 0); if (!__pyx_t_3) { goto __pyx_L18_next_or; } else { } __pyx_t_3 = ((__pyx_v_pt2.y > __pyx_v_y2) != 0); if (!__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L13_bool_binop_done; } __pyx_L18_next_or:; __pyx_t_3 = ((__pyx_v_pt2.y < __pyx_v_y1) != 0); if (__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L13_bool_binop_done; } __pyx_t_3 = ((__pyx_v_pt2.y < __pyx_v_y2) != 0); __pyx_t_2 = __pyx_t_3; __pyx_L13_bool_binop_done:; if (__pyx_t_2) { /* "regions/_geometry/core.pyx":251 * pt1.x, pt1.y = 2., 2. * if (pt2.x > x1 and pt2.x > x2) or (pt2.x < x1 and pt2.x < x2) or (pt2.y > y1 and pt2.y > y2) or (pt2.y < y1 and pt2.y < y2): * pt2.x, pt2.y = 2., 2. # <<<<<<<<<<<<<< * * if pt1.x > 1. and pt2.x < 2.: */ __pyx_t_5 = 2.; __pyx_t_4 = 2.; __pyx_v_pt2.x = __pyx_t_5; __pyx_v_pt2.y = __pyx_t_4; /* "regions/_geometry/core.pyx":250 * if (pt1.x > x1 and pt1.x > x2) or (pt1.x < x1 and pt1.x < x2) or (pt1.y > y1 and pt1.y > y2) or (pt1.y < y1 and pt1.y < y2): * pt1.x, pt1.y = 2., 2. * if (pt2.x > x1 and pt2.x > x2) or (pt2.x < x1 and pt2.x < x2) or (pt2.y > y1 and pt2.y > y2) or (pt2.y < y1 and pt2.y < y2): # <<<<<<<<<<<<<< * pt2.x, pt2.y = 2., 2. * */ } /* "regions/_geometry/core.pyx":253 * pt2.x, pt2.y = 2., 2. * * if pt1.x > 1. and pt2.x < 2.: # <<<<<<<<<<<<<< * inter_new.p1 = pt1 * inter_new.p2 = pt2 */ __pyx_t_3 = ((__pyx_v_pt1.x > 1.) != 0); if (__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L22_bool_binop_done; } __pyx_t_3 = ((__pyx_v_pt2.x < 2.) != 0); __pyx_t_2 = __pyx_t_3; __pyx_L22_bool_binop_done:; if (__pyx_t_2) { /* "regions/_geometry/core.pyx":254 * * if pt1.x > 1. and pt2.x < 2.: * inter_new.p1 = pt1 # <<<<<<<<<<<<<< * inter_new.p2 = pt2 * else: */ __pyx_v_inter_new.p1 = __pyx_v_pt1; /* "regions/_geometry/core.pyx":255 * if pt1.x > 1. and pt2.x < 2.: * inter_new.p1 = pt1 * inter_new.p2 = pt2 # <<<<<<<<<<<<<< * else: * inter_new.p1 = pt2 */ __pyx_v_inter_new.p2 = __pyx_v_pt2; /* "regions/_geometry/core.pyx":253 * pt2.x, pt2.y = 2., 2. * * if pt1.x > 1. and pt2.x < 2.: # <<<<<<<<<<<<<< * inter_new.p1 = pt1 * inter_new.p2 = pt2 */ goto __pyx_L21; } /* "regions/_geometry/core.pyx":257 * inter_new.p2 = pt2 * else: * inter_new.p1 = pt2 # <<<<<<<<<<<<<< * inter_new.p2 = pt1 * */ /*else*/ { __pyx_v_inter_new.p1 = __pyx_v_pt2; /* "regions/_geometry/core.pyx":258 * else: * inter_new.p1 = pt2 * inter_new.p2 = pt1 # <<<<<<<<<<<<<< * * return inter_new */ __pyx_v_inter_new.p2 = __pyx_v_pt1; } __pyx_L21:; /* "regions/_geometry/core.pyx":260 * inter_new.p2 = pt1 * * return inter_new # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_inter_new; goto __pyx_L0; /* "regions/_geometry/core.pyx":234 * * * cdef intersections circle_segment(double x1, double y1, double x2, double y2): # <<<<<<<<<<<<<< * """ * Intersection(s) of a segment with the unit circle. Discard any */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/core.pyx":263 * * * cdef double overlap_area_triangle_unit_circle(double x1, double y1, double x2, double y2, double x3, double y3): # <<<<<<<<<<<<<< * """ * Given a triangle defined by three points (x1, y1), (x2, y2), and */ static double __pyx_f_7regions_9_geometry_4core_overlap_area_triangle_unit_circle(double __pyx_v_x1, double __pyx_v_y1, double __pyx_v_x2, double __pyx_v_y2, double __pyx_v_x3, double __pyx_v_y3) { double __pyx_v_d1; double __pyx_v_d2; double __pyx_v_d3; PyBoolObject *__pyx_v_in1 = 0; PyBoolObject *__pyx_v_in2 = 0; PyBoolObject *__pyx_v_in3 = 0; PyBoolObject *__pyx_v_on1 = 0; PyBoolObject *__pyx_v_on2 = 0; PyBoolObject *__pyx_v_on3 = 0; double __pyx_v_area; double __pyx_v_PI; __pyx_t_7regions_9_geometry_4core_intersections __pyx_v_inter; __pyx_t_7regions_9_geometry_4core_point __pyx_v_pt1; __pyx_t_7regions_9_geometry_4core_point __pyx_v_pt2; __pyx_t_7regions_9_geometry_4core_point __pyx_v_pt3; __pyx_t_7regions_9_geometry_4core_point __pyx_v_pt4; __pyx_t_7regions_9_geometry_4core_point __pyx_v_pt5; __pyx_t_7regions_9_geometry_4core_point __pyx_v_pt6; PyObject *__pyx_v_intersect13 = NULL; PyObject *__pyx_v_intersect23 = NULL; double __pyx_v_xp; double __pyx_v_yp; double __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; double __pyx_t_3; int __pyx_t_4; double __pyx_t_5; double __pyx_t_6; double __pyx_t_7; double __pyx_t_8; double __pyx_t_9; double __pyx_t_10; double __pyx_t_11; double __pyx_t_12; int __pyx_t_13; int __pyx_t_14; __pyx_t_7regions_9_geometry_4core_point __pyx_t_15; __pyx_t_7regions_9_geometry_4core_point __pyx_t_16; __Pyx_RefNannySetupContext("overlap_area_triangle_unit_circle", 0); /* "regions/_geometry/core.pyx":273 * cdef bool on1, on2, on3 * cdef double area * cdef double PI = np.pi # <<<<<<<<<<<<<< * cdef intersections inter * cdef point pt1, pt2, pt3, pt4, pt5, pt6, pt_tmp */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_pi); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 273, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_PI = __pyx_t_3; /* "regions/_geometry/core.pyx":278 * * # Find distance of all vertices to circle center * d1 = x1 * x1 + y1 * y1 # <<<<<<<<<<<<<< * d2 = x2 * x2 + y2 * y2 * d3 = x3 * x3 + y3 * y3 */ __pyx_v_d1 = ((__pyx_v_x1 * __pyx_v_x1) + (__pyx_v_y1 * __pyx_v_y1)); /* "regions/_geometry/core.pyx":279 * # Find distance of all vertices to circle center * d1 = x1 * x1 + y1 * y1 * d2 = x2 * x2 + y2 * y2 # <<<<<<<<<<<<<< * d3 = x3 * x3 + y3 * y3 * */ __pyx_v_d2 = ((__pyx_v_x2 * __pyx_v_x2) + (__pyx_v_y2 * __pyx_v_y2)); /* "regions/_geometry/core.pyx":280 * d1 = x1 * x1 + y1 * y1 * d2 = x2 * x2 + y2 * y2 * d3 = x3 * x3 + y3 * y3 # <<<<<<<<<<<<<< * * # Order vertices by distance from origin */ __pyx_v_d3 = ((__pyx_v_x3 * __pyx_v_x3) + (__pyx_v_y3 * __pyx_v_y3)); /* "regions/_geometry/core.pyx":283 * * # Order vertices by distance from origin * if d1 < d2: # <<<<<<<<<<<<<< * if d2 < d3: * pass */ __pyx_t_4 = ((__pyx_v_d1 < __pyx_v_d2) != 0); if (__pyx_t_4) { /* "regions/_geometry/core.pyx":284 * # Order vertices by distance from origin * if d1 < d2: * if d2 < d3: # <<<<<<<<<<<<<< * pass * elif d1 < d3: */ __pyx_t_4 = ((__pyx_v_d2 < __pyx_v_d3) != 0); if (__pyx_t_4) { goto __pyx_L4; } /* "regions/_geometry/core.pyx":286 * if d2 < d3: * pass * elif d1 < d3: # <<<<<<<<<<<<<< * x2, y2, d2, x3, y3, d3 = x3, y3, d3, x2, y2, d2 * else: */ __pyx_t_4 = ((__pyx_v_d1 < __pyx_v_d3) != 0); if (__pyx_t_4) { /* "regions/_geometry/core.pyx":287 * pass * elif d1 < d3: * x2, y2, d2, x3, y3, d3 = x3, y3, d3, x2, y2, d2 # <<<<<<<<<<<<<< * else: * x1, y1, d1, x2, y2, d2, x3, y3, d3 = x3, y3, d3, x1, y1, d1, x2, y2, d2 */ __pyx_t_3 = __pyx_v_x3; __pyx_t_5 = __pyx_v_y3; __pyx_t_6 = __pyx_v_d3; __pyx_t_7 = __pyx_v_x2; __pyx_t_8 = __pyx_v_y2; __pyx_t_9 = __pyx_v_d2; __pyx_v_x2 = __pyx_t_3; __pyx_v_y2 = __pyx_t_5; __pyx_v_d2 = __pyx_t_6; __pyx_v_x3 = __pyx_t_7; __pyx_v_y3 = __pyx_t_8; __pyx_v_d3 = __pyx_t_9; /* "regions/_geometry/core.pyx":286 * if d2 < d3: * pass * elif d1 < d3: # <<<<<<<<<<<<<< * x2, y2, d2, x3, y3, d3 = x3, y3, d3, x2, y2, d2 * else: */ goto __pyx_L4; } /* "regions/_geometry/core.pyx":289 * x2, y2, d2, x3, y3, d3 = x3, y3, d3, x2, y2, d2 * else: * x1, y1, d1, x2, y2, d2, x3, y3, d3 = x3, y3, d3, x1, y1, d1, x2, y2, d2 # <<<<<<<<<<<<<< * * else: */ /*else*/ { __pyx_t_9 = __pyx_v_x3; __pyx_t_8 = __pyx_v_y3; __pyx_t_7 = __pyx_v_d3; __pyx_t_6 = __pyx_v_x1; __pyx_t_5 = __pyx_v_y1; __pyx_t_3 = __pyx_v_d1; __pyx_t_10 = __pyx_v_x2; __pyx_t_11 = __pyx_v_y2; __pyx_t_12 = __pyx_v_d2; __pyx_v_x1 = __pyx_t_9; __pyx_v_y1 = __pyx_t_8; __pyx_v_d1 = __pyx_t_7; __pyx_v_x2 = __pyx_t_6; __pyx_v_y2 = __pyx_t_5; __pyx_v_d2 = __pyx_t_3; __pyx_v_x3 = __pyx_t_10; __pyx_v_y3 = __pyx_t_11; __pyx_v_d3 = __pyx_t_12; } __pyx_L4:; /* "regions/_geometry/core.pyx":283 * * # Order vertices by distance from origin * if d1 < d2: # <<<<<<<<<<<<<< * if d2 < d3: * pass */ goto __pyx_L3; } /* "regions/_geometry/core.pyx":292 * * else: * if d1 < d3: # <<<<<<<<<<<<<< * x1, y1, d1, x2, y2, d2 = x2, y2, d2, x1, y1, d1 * elif d2 < d3: */ /*else*/ { __pyx_t_4 = ((__pyx_v_d1 < __pyx_v_d3) != 0); if (__pyx_t_4) { /* "regions/_geometry/core.pyx":293 * else: * if d1 < d3: * x1, y1, d1, x2, y2, d2 = x2, y2, d2, x1, y1, d1 # <<<<<<<<<<<<<< * elif d2 < d3: * x1, y1, d1, x2, y2, d2, x3, y3, d3 = x2, y2, d2, x3, y3, d3, x1, y1, d1 */ __pyx_t_12 = __pyx_v_x2; __pyx_t_11 = __pyx_v_y2; __pyx_t_10 = __pyx_v_d2; __pyx_t_3 = __pyx_v_x1; __pyx_t_5 = __pyx_v_y1; __pyx_t_6 = __pyx_v_d1; __pyx_v_x1 = __pyx_t_12; __pyx_v_y1 = __pyx_t_11; __pyx_v_d1 = __pyx_t_10; __pyx_v_x2 = __pyx_t_3; __pyx_v_y2 = __pyx_t_5; __pyx_v_d2 = __pyx_t_6; /* "regions/_geometry/core.pyx":292 * * else: * if d1 < d3: # <<<<<<<<<<<<<< * x1, y1, d1, x2, y2, d2 = x2, y2, d2, x1, y1, d1 * elif d2 < d3: */ goto __pyx_L5; } /* "regions/_geometry/core.pyx":294 * if d1 < d3: * x1, y1, d1, x2, y2, d2 = x2, y2, d2, x1, y1, d1 * elif d2 < d3: # <<<<<<<<<<<<<< * x1, y1, d1, x2, y2, d2, x3, y3, d3 = x2, y2, d2, x3, y3, d3, x1, y1, d1 * else: */ __pyx_t_4 = ((__pyx_v_d2 < __pyx_v_d3) != 0); if (__pyx_t_4) { /* "regions/_geometry/core.pyx":295 * x1, y1, d1, x2, y2, d2 = x2, y2, d2, x1, y1, d1 * elif d2 < d3: * x1, y1, d1, x2, y2, d2, x3, y3, d3 = x2, y2, d2, x3, y3, d3, x1, y1, d1 # <<<<<<<<<<<<<< * else: * x1, y1, d1, x2, y2, d2, x3, y3, d3 = x3, y3, d3, x2, y2, d2, x1, y1, d1 */ __pyx_t_6 = __pyx_v_x2; __pyx_t_5 = __pyx_v_y2; __pyx_t_3 = __pyx_v_d2; __pyx_t_10 = __pyx_v_x3; __pyx_t_11 = __pyx_v_y3; __pyx_t_12 = __pyx_v_d3; __pyx_t_7 = __pyx_v_x1; __pyx_t_8 = __pyx_v_y1; __pyx_t_9 = __pyx_v_d1; __pyx_v_x1 = __pyx_t_6; __pyx_v_y1 = __pyx_t_5; __pyx_v_d1 = __pyx_t_3; __pyx_v_x2 = __pyx_t_10; __pyx_v_y2 = __pyx_t_11; __pyx_v_d2 = __pyx_t_12; __pyx_v_x3 = __pyx_t_7; __pyx_v_y3 = __pyx_t_8; __pyx_v_d3 = __pyx_t_9; /* "regions/_geometry/core.pyx":294 * if d1 < d3: * x1, y1, d1, x2, y2, d2 = x2, y2, d2, x1, y1, d1 * elif d2 < d3: # <<<<<<<<<<<<<< * x1, y1, d1, x2, y2, d2, x3, y3, d3 = x2, y2, d2, x3, y3, d3, x1, y1, d1 * else: */ goto __pyx_L5; } /* "regions/_geometry/core.pyx":297 * x1, y1, d1, x2, y2, d2, x3, y3, d3 = x2, y2, d2, x3, y3, d3, x1, y1, d1 * else: * x1, y1, d1, x2, y2, d2, x3, y3, d3 = x3, y3, d3, x2, y2, d2, x1, y1, d1 # <<<<<<<<<<<<<< * * if d1 > d2 or d2 > d3 or d1 > d3: */ /*else*/ { __pyx_t_9 = __pyx_v_x3; __pyx_t_8 = __pyx_v_y3; __pyx_t_7 = __pyx_v_d3; __pyx_t_12 = __pyx_v_x2; __pyx_t_11 = __pyx_v_y2; __pyx_t_10 = __pyx_v_d2; __pyx_t_3 = __pyx_v_x1; __pyx_t_5 = __pyx_v_y1; __pyx_t_6 = __pyx_v_d1; __pyx_v_x1 = __pyx_t_9; __pyx_v_y1 = __pyx_t_8; __pyx_v_d1 = __pyx_t_7; __pyx_v_x2 = __pyx_t_12; __pyx_v_y2 = __pyx_t_11; __pyx_v_d2 = __pyx_t_10; __pyx_v_x3 = __pyx_t_3; __pyx_v_y3 = __pyx_t_5; __pyx_v_d3 = __pyx_t_6; } __pyx_L5:; } __pyx_L3:; /* "regions/_geometry/core.pyx":299 * x1, y1, d1, x2, y2, d2, x3, y3, d3 = x3, y3, d3, x2, y2, d2, x1, y1, d1 * * if d1 > d2 or d2 > d3 or d1 > d3: # <<<<<<<<<<<<<< * raise Exception("ERROR: vertices did not sort correctly") * */ __pyx_t_13 = ((__pyx_v_d1 > __pyx_v_d2) != 0); if (!__pyx_t_13) { } else { __pyx_t_4 = __pyx_t_13; goto __pyx_L7_bool_binop_done; } __pyx_t_13 = ((__pyx_v_d2 > __pyx_v_d3) != 0); if (!__pyx_t_13) { } else { __pyx_t_4 = __pyx_t_13; goto __pyx_L7_bool_binop_done; } __pyx_t_13 = ((__pyx_v_d1 > __pyx_v_d3) != 0); __pyx_t_4 = __pyx_t_13; __pyx_L7_bool_binop_done:; if (unlikely(__pyx_t_4)) { /* "regions/_geometry/core.pyx":300 * * if d1 > d2 or d2 > d3 or d1 > d3: * raise Exception("ERROR: vertices did not sort correctly") # <<<<<<<<<<<<<< * * # Determine number of vertices inside circle */ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple_, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 300, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 300, __pyx_L1_error) /* "regions/_geometry/core.pyx":299 * x1, y1, d1, x2, y2, d2, x3, y3, d3 = x3, y3, d3, x2, y2, d2, x1, y1, d1 * * if d1 > d2 or d2 > d3 or d1 > d3: # <<<<<<<<<<<<<< * raise Exception("ERROR: vertices did not sort correctly") * */ } /* "regions/_geometry/core.pyx":303 * * # Determine number of vertices inside circle * in1 = d1 < 1 # <<<<<<<<<<<<<< * in2 = d2 < 1 * in3 = d3 < 1 */ __pyx_t_2 = __Pyx_PyBool_FromLong((__pyx_v_d1 < 1.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (!(likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_7cpython_4bool_bool)))) __PYX_ERR(0, 303, __pyx_L1_error) __pyx_v_in1 = ((PyBoolObject *)__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/core.pyx":304 * # Determine number of vertices inside circle * in1 = d1 < 1 * in2 = d2 < 1 # <<<<<<<<<<<<<< * in3 = d3 < 1 * */ __pyx_t_2 = __Pyx_PyBool_FromLong((__pyx_v_d2 < 1.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (!(likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_7cpython_4bool_bool)))) __PYX_ERR(0, 304, __pyx_L1_error) __pyx_v_in2 = ((PyBoolObject *)__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/core.pyx":305 * in1 = d1 < 1 * in2 = d2 < 1 * in3 = d3 < 1 # <<<<<<<<<<<<<< * * # Determine which vertices are on the circle */ __pyx_t_2 = __Pyx_PyBool_FromLong((__pyx_v_d3 < 1.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (!(likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_7cpython_4bool_bool)))) __PYX_ERR(0, 305, __pyx_L1_error) __pyx_v_in3 = ((PyBoolObject *)__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/core.pyx":308 * * # Determine which vertices are on the circle * on1 = fabs(d1 - 1) < 1.e-10 # <<<<<<<<<<<<<< * on2 = fabs(d2 - 1) < 1.e-10 * on3 = fabs(d3 - 1) < 1.e-10 */ __pyx_t_2 = __Pyx_PyBool_FromLong((fabs((__pyx_v_d1 - 1.0)) < 1.e-10)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 308, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (!(likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_7cpython_4bool_bool)))) __PYX_ERR(0, 308, __pyx_L1_error) __pyx_v_on1 = ((PyBoolObject *)__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/core.pyx":309 * # Determine which vertices are on the circle * on1 = fabs(d1 - 1) < 1.e-10 * on2 = fabs(d2 - 1) < 1.e-10 # <<<<<<<<<<<<<< * on3 = fabs(d3 - 1) < 1.e-10 * */ __pyx_t_2 = __Pyx_PyBool_FromLong((fabs((__pyx_v_d2 - 1.0)) < 1.e-10)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (!(likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_7cpython_4bool_bool)))) __PYX_ERR(0, 309, __pyx_L1_error) __pyx_v_on2 = ((PyBoolObject *)__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/core.pyx":310 * on1 = fabs(d1 - 1) < 1.e-10 * on2 = fabs(d2 - 1) < 1.e-10 * on3 = fabs(d3 - 1) < 1.e-10 # <<<<<<<<<<<<<< * * if on3 or in3: # triangle is completely in circle */ __pyx_t_2 = __Pyx_PyBool_FromLong((fabs((__pyx_v_d3 - 1.0)) < 1.e-10)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (!(likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_7cpython_4bool_bool)))) __PYX_ERR(0, 310, __pyx_L1_error) __pyx_v_on3 = ((PyBoolObject *)__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/core.pyx":312 * on3 = fabs(d3 - 1) < 1.e-10 * * if on3 or in3: # triangle is completely in circle # <<<<<<<<<<<<<< * * area = area_triangle(x1, y1, x2, y2, x3, y3) */ __pyx_t_13 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_on3)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 312, __pyx_L1_error) if (!__pyx_t_13) { } else { __pyx_t_4 = __pyx_t_13; goto __pyx_L11_bool_binop_done; } __pyx_t_13 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_in3)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 312, __pyx_L1_error) __pyx_t_4 = __pyx_t_13; __pyx_L11_bool_binop_done:; if (__pyx_t_4) { /* "regions/_geometry/core.pyx":314 * if on3 or in3: # triangle is completely in circle * * area = area_triangle(x1, y1, x2, y2, x3, y3) # <<<<<<<<<<<<<< * * elif in2 or on2: */ __pyx_v_area = __pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2, __pyx_v_x3, __pyx_v_y3); /* "regions/_geometry/core.pyx":312 * on3 = fabs(d3 - 1) < 1.e-10 * * if on3 or in3: # triangle is completely in circle # <<<<<<<<<<<<<< * * area = area_triangle(x1, y1, x2, y2, x3, y3) */ goto __pyx_L10; } /* "regions/_geometry/core.pyx":316 * area = area_triangle(x1, y1, x2, y2, x3, y3) * * elif in2 or on2: # <<<<<<<<<<<<<< * # If vertex 1 or 2 are on the edge of the circle, then we use the dot * # product to vertex 3 to determine whether an intersection takes place. */ __pyx_t_13 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_in2)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 316, __pyx_L1_error) if (!__pyx_t_13) { } else { __pyx_t_4 = __pyx_t_13; goto __pyx_L13_bool_binop_done; } __pyx_t_13 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_on2)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 316, __pyx_L1_error) __pyx_t_4 = __pyx_t_13; __pyx_L13_bool_binop_done:; if (__pyx_t_4) { /* "regions/_geometry/core.pyx":319 * # If vertex 1 or 2 are on the edge of the circle, then we use the dot * # product to vertex 3 to determine whether an intersection takes place. * intersect13 = not on1 or x1 * (x3 - x1) + y1 * (y3 - y1) < 0. # <<<<<<<<<<<<<< * intersect23 = not on2 or x2 * (x3 - x2) + y2 * (y3 - y2) < 0. * if intersect13 and intersect23 and not on2: */ __pyx_t_4 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_on1)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 319, __pyx_L1_error) __pyx_t_13 = (!__pyx_t_4); if (!__pyx_t_13) { } else { __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_13); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L15_bool_binop_done; } __pyx_t_13 = (((__pyx_v_x1 * (__pyx_v_x3 - __pyx_v_x1)) + (__pyx_v_y1 * (__pyx_v_y3 - __pyx_v_y1))) < 0.); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_13); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_t_1; __pyx_t_1 = 0; __pyx_L15_bool_binop_done:; __pyx_v_intersect13 = __pyx_t_2; __pyx_t_2 = 0; /* "regions/_geometry/core.pyx":320 * # product to vertex 3 to determine whether an intersection takes place. * intersect13 = not on1 or x1 * (x3 - x1) + y1 * (y3 - y1) < 0. * intersect23 = not on2 or x2 * (x3 - x2) + y2 * (y3 - y2) < 0. # <<<<<<<<<<<<<< * if intersect13 and intersect23 and not on2: * pt1 = circle_segment_single2(x1, y1, x3, y3) */ __pyx_t_13 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_on2)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 320, __pyx_L1_error) __pyx_t_4 = (!__pyx_t_13); if (!__pyx_t_4) { } else { __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L17_bool_binop_done; } __pyx_t_4 = (((__pyx_v_x2 * (__pyx_v_x3 - __pyx_v_x2)) + (__pyx_v_y2 * (__pyx_v_y3 - __pyx_v_y2))) < 0.); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_t_1; __pyx_t_1 = 0; __pyx_L17_bool_binop_done:; __pyx_v_intersect23 = __pyx_t_2; __pyx_t_2 = 0; /* "regions/_geometry/core.pyx":321 * intersect13 = not on1 or x1 * (x3 - x1) + y1 * (y3 - y1) < 0. * intersect23 = not on2 or x2 * (x3 - x2) + y2 * (y3 - y2) < 0. * if intersect13 and intersect23 and not on2: # <<<<<<<<<<<<<< * pt1 = circle_segment_single2(x1, y1, x3, y3) * pt2 = circle_segment_single2(x2, y2, x3, y3) */ __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_intersect13); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 321, __pyx_L1_error) if (__pyx_t_13) { } else { __pyx_t_4 = __pyx_t_13; goto __pyx_L20_bool_binop_done; } __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_intersect23); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 321, __pyx_L1_error) if (__pyx_t_13) { } else { __pyx_t_4 = __pyx_t_13; goto __pyx_L20_bool_binop_done; } __pyx_t_13 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_on2)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 321, __pyx_L1_error) __pyx_t_14 = ((!__pyx_t_13) != 0); __pyx_t_4 = __pyx_t_14; __pyx_L20_bool_binop_done:; if (__pyx_t_4) { /* "regions/_geometry/core.pyx":322 * intersect23 = not on2 or x2 * (x3 - x2) + y2 * (y3 - y2) < 0. * if intersect13 and intersect23 and not on2: * pt1 = circle_segment_single2(x1, y1, x3, y3) # <<<<<<<<<<<<<< * pt2 = circle_segment_single2(x2, y2, x3, y3) * area = area_triangle(x1, y1, x2, y2, pt1.x, pt1.y) \ */ __pyx_v_pt1 = __pyx_f_7regions_9_geometry_4core_circle_segment_single2(__pyx_v_x1, __pyx_v_y1, __pyx_v_x3, __pyx_v_y3); /* "regions/_geometry/core.pyx":323 * if intersect13 and intersect23 and not on2: * pt1 = circle_segment_single2(x1, y1, x3, y3) * pt2 = circle_segment_single2(x2, y2, x3, y3) # <<<<<<<<<<<<<< * area = area_triangle(x1, y1, x2, y2, pt1.x, pt1.y) \ * + area_triangle(x2, y2, pt1.x, pt1.y, pt2.x, pt2.y) \ */ __pyx_v_pt2 = __pyx_f_7regions_9_geometry_4core_circle_segment_single2(__pyx_v_x2, __pyx_v_y2, __pyx_v_x3, __pyx_v_y3); /* "regions/_geometry/core.pyx":326 * area = area_triangle(x1, y1, x2, y2, pt1.x, pt1.y) \ * + area_triangle(x2, y2, pt1.x, pt1.y, pt2.x, pt2.y) \ * + area_arc_unit(pt1.x, pt1.y, pt2.x, pt2.y) # <<<<<<<<<<<<<< * elif intersect13: * pt1 = circle_segment_single2(x1, y1, x3, y3) */ __pyx_v_area = ((__pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2, __pyx_v_pt1.x, __pyx_v_pt1.y) + __pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x2, __pyx_v_y2, __pyx_v_pt1.x, __pyx_v_pt1.y, __pyx_v_pt2.x, __pyx_v_pt2.y)) + __pyx_f_7regions_9_geometry_4core_area_arc_unit(__pyx_v_pt1.x, __pyx_v_pt1.y, __pyx_v_pt2.x, __pyx_v_pt2.y)); /* "regions/_geometry/core.pyx":321 * intersect13 = not on1 or x1 * (x3 - x1) + y1 * (y3 - y1) < 0. * intersect23 = not on2 or x2 * (x3 - x2) + y2 * (y3 - y2) < 0. * if intersect13 and intersect23 and not on2: # <<<<<<<<<<<<<< * pt1 = circle_segment_single2(x1, y1, x3, y3) * pt2 = circle_segment_single2(x2, y2, x3, y3) */ goto __pyx_L19; } /* "regions/_geometry/core.pyx":327 * + area_triangle(x2, y2, pt1.x, pt1.y, pt2.x, pt2.y) \ * + area_arc_unit(pt1.x, pt1.y, pt2.x, pt2.y) * elif intersect13: # <<<<<<<<<<<<<< * pt1 = circle_segment_single2(x1, y1, x3, y3) * area = area_triangle(x1, y1, x2, y2, pt1.x, pt1.y) \ */ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_intersect13); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 327, __pyx_L1_error) if (__pyx_t_4) { /* "regions/_geometry/core.pyx":328 * + area_arc_unit(pt1.x, pt1.y, pt2.x, pt2.y) * elif intersect13: * pt1 = circle_segment_single2(x1, y1, x3, y3) # <<<<<<<<<<<<<< * area = area_triangle(x1, y1, x2, y2, pt1.x, pt1.y) \ * + area_arc_unit(x2, y2, pt1.x, pt1.y) */ __pyx_v_pt1 = __pyx_f_7regions_9_geometry_4core_circle_segment_single2(__pyx_v_x1, __pyx_v_y1, __pyx_v_x3, __pyx_v_y3); /* "regions/_geometry/core.pyx":330 * pt1 = circle_segment_single2(x1, y1, x3, y3) * area = area_triangle(x1, y1, x2, y2, pt1.x, pt1.y) \ * + area_arc_unit(x2, y2, pt1.x, pt1.y) # <<<<<<<<<<<<<< * elif intersect23: * pt2 = circle_segment_single2(x2, y2, x3, y3) */ __pyx_v_area = (__pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2, __pyx_v_pt1.x, __pyx_v_pt1.y) + __pyx_f_7regions_9_geometry_4core_area_arc_unit(__pyx_v_x2, __pyx_v_y2, __pyx_v_pt1.x, __pyx_v_pt1.y)); /* "regions/_geometry/core.pyx":327 * + area_triangle(x2, y2, pt1.x, pt1.y, pt2.x, pt2.y) \ * + area_arc_unit(pt1.x, pt1.y, pt2.x, pt2.y) * elif intersect13: # <<<<<<<<<<<<<< * pt1 = circle_segment_single2(x1, y1, x3, y3) * area = area_triangle(x1, y1, x2, y2, pt1.x, pt1.y) \ */ goto __pyx_L19; } /* "regions/_geometry/core.pyx":331 * area = area_triangle(x1, y1, x2, y2, pt1.x, pt1.y) \ * + area_arc_unit(x2, y2, pt1.x, pt1.y) * elif intersect23: # <<<<<<<<<<<<<< * pt2 = circle_segment_single2(x2, y2, x3, y3) * area = area_triangle(x1, y1, x2, y2, pt2.x, pt2.y) \ */ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_intersect23); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 331, __pyx_L1_error) if (__pyx_t_4) { /* "regions/_geometry/core.pyx":332 * + area_arc_unit(x2, y2, pt1.x, pt1.y) * elif intersect23: * pt2 = circle_segment_single2(x2, y2, x3, y3) # <<<<<<<<<<<<<< * area = area_triangle(x1, y1, x2, y2, pt2.x, pt2.y) \ * + area_arc_unit(x1, y1, pt2.x, pt2.y) */ __pyx_v_pt2 = __pyx_f_7regions_9_geometry_4core_circle_segment_single2(__pyx_v_x2, __pyx_v_y2, __pyx_v_x3, __pyx_v_y3); /* "regions/_geometry/core.pyx":334 * pt2 = circle_segment_single2(x2, y2, x3, y3) * area = area_triangle(x1, y1, x2, y2, pt2.x, pt2.y) \ * + area_arc_unit(x1, y1, pt2.x, pt2.y) # <<<<<<<<<<<<<< * else: * area = area_arc_unit(x1, y1, x2, y2) */ __pyx_v_area = (__pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2, __pyx_v_pt2.x, __pyx_v_pt2.y) + __pyx_f_7regions_9_geometry_4core_area_arc_unit(__pyx_v_x1, __pyx_v_y1, __pyx_v_pt2.x, __pyx_v_pt2.y)); /* "regions/_geometry/core.pyx":331 * area = area_triangle(x1, y1, x2, y2, pt1.x, pt1.y) \ * + area_arc_unit(x2, y2, pt1.x, pt1.y) * elif intersect23: # <<<<<<<<<<<<<< * pt2 = circle_segment_single2(x2, y2, x3, y3) * area = area_triangle(x1, y1, x2, y2, pt2.x, pt2.y) \ */ goto __pyx_L19; } /* "regions/_geometry/core.pyx":336 * + area_arc_unit(x1, y1, pt2.x, pt2.y) * else: * area = area_arc_unit(x1, y1, x2, y2) # <<<<<<<<<<<<<< * * elif on1: */ /*else*/ { __pyx_v_area = __pyx_f_7regions_9_geometry_4core_area_arc_unit(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2); } __pyx_L19:; /* "regions/_geometry/core.pyx":316 * area = area_triangle(x1, y1, x2, y2, x3, y3) * * elif in2 or on2: # <<<<<<<<<<<<<< * # If vertex 1 or 2 are on the edge of the circle, then we use the dot * # product to vertex 3 to determine whether an intersection takes place. */ goto __pyx_L10; } /* "regions/_geometry/core.pyx":338 * area = area_arc_unit(x1, y1, x2, y2) * * elif on1: # <<<<<<<<<<<<<< * # The triangle is outside the circle * area = 0.0 */ __pyx_t_4 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_on1)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 338, __pyx_L1_error) if (__pyx_t_4) { /* "regions/_geometry/core.pyx":340 * elif on1: * # The triangle is outside the circle * area = 0.0 # <<<<<<<<<<<<<< * elif in1: * # Check for intersections of far side with circle */ __pyx_v_area = 0.0; /* "regions/_geometry/core.pyx":338 * area = area_arc_unit(x1, y1, x2, y2) * * elif on1: # <<<<<<<<<<<<<< * # The triangle is outside the circle * area = 0.0 */ goto __pyx_L10; } /* "regions/_geometry/core.pyx":341 * # The triangle is outside the circle * area = 0.0 * elif in1: # <<<<<<<<<<<<<< * # Check for intersections of far side with circle * inter = circle_segment(x2, y2, x3, y3) */ __pyx_t_4 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_in1)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 341, __pyx_L1_error) if (__pyx_t_4) { /* "regions/_geometry/core.pyx":343 * elif in1: * # Check for intersections of far side with circle * inter = circle_segment(x2, y2, x3, y3) # <<<<<<<<<<<<<< * pt1 = inter.p1 * pt2 = inter.p2 */ __pyx_v_inter = __pyx_f_7regions_9_geometry_4core_circle_segment(__pyx_v_x2, __pyx_v_y2, __pyx_v_x3, __pyx_v_y3); /* "regions/_geometry/core.pyx":344 * # Check for intersections of far side with circle * inter = circle_segment(x2, y2, x3, y3) * pt1 = inter.p1 # <<<<<<<<<<<<<< * pt2 = inter.p2 * pt3 = circle_segment_single2(x1, y1, x2, y2) */ __pyx_t_15 = __pyx_v_inter.p1; __pyx_v_pt1 = __pyx_t_15; /* "regions/_geometry/core.pyx":345 * inter = circle_segment(x2, y2, x3, y3) * pt1 = inter.p1 * pt2 = inter.p2 # <<<<<<<<<<<<<< * pt3 = circle_segment_single2(x1, y1, x2, y2) * pt4 = circle_segment_single2(x1, y1, x3, y3) */ __pyx_t_15 = __pyx_v_inter.p2; __pyx_v_pt2 = __pyx_t_15; /* "regions/_geometry/core.pyx":346 * pt1 = inter.p1 * pt2 = inter.p2 * pt3 = circle_segment_single2(x1, y1, x2, y2) # <<<<<<<<<<<<<< * pt4 = circle_segment_single2(x1, y1, x3, y3) * if pt1.x > 1.: # indicates no intersection */ __pyx_v_pt3 = __pyx_f_7regions_9_geometry_4core_circle_segment_single2(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2); /* "regions/_geometry/core.pyx":347 * pt2 = inter.p2 * pt3 = circle_segment_single2(x1, y1, x2, y2) * pt4 = circle_segment_single2(x1, y1, x3, y3) # <<<<<<<<<<<<<< * if pt1.x > 1.: # indicates no intersection * # Code taken from `sep.h`. */ __pyx_v_pt4 = __pyx_f_7regions_9_geometry_4core_circle_segment_single2(__pyx_v_x1, __pyx_v_y1, __pyx_v_x3, __pyx_v_y3); /* "regions/_geometry/core.pyx":348 * pt3 = circle_segment_single2(x1, y1, x2, y2) * pt4 = circle_segment_single2(x1, y1, x3, y3) * if pt1.x > 1.: # indicates no intersection # <<<<<<<<<<<<<< * # Code taken from `sep.h`. * # TODO: use `sep` and get rid of this Cython code. */ __pyx_t_4 = ((__pyx_v_pt1.x > 1.) != 0); if (__pyx_t_4) { /* "regions/_geometry/core.pyx":351 * # Code taken from `sep.h`. * # TODO: use `sep` and get rid of this Cython code. * if (((0.-pt3.y) * (pt4.x-pt3.x) > (pt4.y-pt3.y) * (0.-pt3.x)) != # <<<<<<<<<<<<<< * ((y1-pt3.y) * (pt4.x-pt3.x) > (pt4.y-pt3.y) * (x1-pt3.x))): * area = area_triangle(x1, y1, pt3.x, pt3.y, pt4.x, pt4.y) \ */ __pyx_t_4 = (((((0. - __pyx_v_pt3.y) * (__pyx_v_pt4.x - __pyx_v_pt3.x)) > ((__pyx_v_pt4.y - __pyx_v_pt3.y) * (0. - __pyx_v_pt3.x))) != (((__pyx_v_y1 - __pyx_v_pt3.y) * (__pyx_v_pt4.x - __pyx_v_pt3.x)) > ((__pyx_v_pt4.y - __pyx_v_pt3.y) * (__pyx_v_x1 - __pyx_v_pt3.x)))) != 0); if (__pyx_t_4) { /* "regions/_geometry/core.pyx":354 * ((y1-pt3.y) * (pt4.x-pt3.x) > (pt4.y-pt3.y) * (x1-pt3.x))): * area = area_triangle(x1, y1, pt3.x, pt3.y, pt4.x, pt4.y) \ * + (PI - area_arc_unit(pt3.x, pt3.y, pt4.x, pt4.y)) # <<<<<<<<<<<<<< * else: * area = area_triangle(x1, y1, pt3.x, pt3.y, pt4.x, pt4.y) \ */ __pyx_v_area = (__pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_pt3.x, __pyx_v_pt3.y, __pyx_v_pt4.x, __pyx_v_pt4.y) + (__pyx_v_PI - __pyx_f_7regions_9_geometry_4core_area_arc_unit(__pyx_v_pt3.x, __pyx_v_pt3.y, __pyx_v_pt4.x, __pyx_v_pt4.y))); /* "regions/_geometry/core.pyx":351 * # Code taken from `sep.h`. * # TODO: use `sep` and get rid of this Cython code. * if (((0.-pt3.y) * (pt4.x-pt3.x) > (pt4.y-pt3.y) * (0.-pt3.x)) != # <<<<<<<<<<<<<< * ((y1-pt3.y) * (pt4.x-pt3.x) > (pt4.y-pt3.y) * (x1-pt3.x))): * area = area_triangle(x1, y1, pt3.x, pt3.y, pt4.x, pt4.y) \ */ goto __pyx_L24; } /* "regions/_geometry/core.pyx":357 * else: * area = area_triangle(x1, y1, pt3.x, pt3.y, pt4.x, pt4.y) \ * + area_arc_unit(pt3.x, pt3.y, pt4.x, pt4.y) # <<<<<<<<<<<<<< * else: * if (pt2.x - x2)**2 + (pt2.y - y2)**2 < (pt1.x - x2)**2 + (pt1.y - y2)**2: */ /*else*/ { /* "regions/_geometry/core.pyx":356 * + (PI - area_arc_unit(pt3.x, pt3.y, pt4.x, pt4.y)) * else: * area = area_triangle(x1, y1, pt3.x, pt3.y, pt4.x, pt4.y) \ # <<<<<<<<<<<<<< * + area_arc_unit(pt3.x, pt3.y, pt4.x, pt4.y) * else: */ __pyx_v_area = (__pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_pt3.x, __pyx_v_pt3.y, __pyx_v_pt4.x, __pyx_v_pt4.y) + __pyx_f_7regions_9_geometry_4core_area_arc_unit(__pyx_v_pt3.x, __pyx_v_pt3.y, __pyx_v_pt4.x, __pyx_v_pt4.y)); } __pyx_L24:; /* "regions/_geometry/core.pyx":348 * pt3 = circle_segment_single2(x1, y1, x2, y2) * pt4 = circle_segment_single2(x1, y1, x3, y3) * if pt1.x > 1.: # indicates no intersection # <<<<<<<<<<<<<< * # Code taken from `sep.h`. * # TODO: use `sep` and get rid of this Cython code. */ goto __pyx_L23; } /* "regions/_geometry/core.pyx":359 * + area_arc_unit(pt3.x, pt3.y, pt4.x, pt4.y) * else: * if (pt2.x - x2)**2 + (pt2.y - y2)**2 < (pt1.x - x2)**2 + (pt1.y - y2)**2: # <<<<<<<<<<<<<< * pt1, pt2 = pt2, pt1 * area = area_triangle(x1, y1, pt3.x, pt3.y, pt1.x, pt1.y) \ */ /*else*/ { __pyx_t_4 = (((pow((__pyx_v_pt2.x - __pyx_v_x2), 2.0) + pow((__pyx_v_pt2.y - __pyx_v_y2), 2.0)) < (pow((__pyx_v_pt1.x - __pyx_v_x2), 2.0) + pow((__pyx_v_pt1.y - __pyx_v_y2), 2.0))) != 0); if (__pyx_t_4) { /* "regions/_geometry/core.pyx":360 * else: * if (pt2.x - x2)**2 + (pt2.y - y2)**2 < (pt1.x - x2)**2 + (pt1.y - y2)**2: * pt1, pt2 = pt2, pt1 # <<<<<<<<<<<<<< * area = area_triangle(x1, y1, pt3.x, pt3.y, pt1.x, pt1.y) \ * + area_triangle(x1, y1, pt1.x, pt1.y, pt2.x, pt2.y) \ */ __pyx_t_15 = __pyx_v_pt2; __pyx_t_16 = __pyx_v_pt1; __pyx_v_pt1 = __pyx_t_15; __pyx_v_pt2 = __pyx_t_16; /* "regions/_geometry/core.pyx":359 * + area_arc_unit(pt3.x, pt3.y, pt4.x, pt4.y) * else: * if (pt2.x - x2)**2 + (pt2.y - y2)**2 < (pt1.x - x2)**2 + (pt1.y - y2)**2: # <<<<<<<<<<<<<< * pt1, pt2 = pt2, pt1 * area = area_triangle(x1, y1, pt3.x, pt3.y, pt1.x, pt1.y) \ */ } /* "regions/_geometry/core.pyx":365 * + area_triangle(x1, y1, pt2.x, pt2.y, pt4.x, pt4.y) \ * + area_arc_unit(pt1.x, pt1.y, pt3.x, pt3.y) \ * + area_arc_unit(pt2.x, pt2.y, pt4.x, pt4.y) # <<<<<<<<<<<<<< * else: * inter = circle_segment(x1, y1, x2, y2) */ __pyx_v_area = ((((__pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_pt3.x, __pyx_v_pt3.y, __pyx_v_pt1.x, __pyx_v_pt1.y) + __pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_pt1.x, __pyx_v_pt1.y, __pyx_v_pt2.x, __pyx_v_pt2.y)) + __pyx_f_7regions_9_geometry_4core_area_triangle(__pyx_v_x1, __pyx_v_y1, __pyx_v_pt2.x, __pyx_v_pt2.y, __pyx_v_pt4.x, __pyx_v_pt4.y)) + __pyx_f_7regions_9_geometry_4core_area_arc_unit(__pyx_v_pt1.x, __pyx_v_pt1.y, __pyx_v_pt3.x, __pyx_v_pt3.y)) + __pyx_f_7regions_9_geometry_4core_area_arc_unit(__pyx_v_pt2.x, __pyx_v_pt2.y, __pyx_v_pt4.x, __pyx_v_pt4.y)); } __pyx_L23:; /* "regions/_geometry/core.pyx":341 * # The triangle is outside the circle * area = 0.0 * elif in1: # <<<<<<<<<<<<<< * # Check for intersections of far side with circle * inter = circle_segment(x2, y2, x3, y3) */ goto __pyx_L10; } /* "regions/_geometry/core.pyx":367 * + area_arc_unit(pt2.x, pt2.y, pt4.x, pt4.y) * else: * inter = circle_segment(x1, y1, x2, y2) # <<<<<<<<<<<<<< * pt1 = inter.p1 * pt2 = inter.p2 */ /*else*/ { __pyx_v_inter = __pyx_f_7regions_9_geometry_4core_circle_segment(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2); /* "regions/_geometry/core.pyx":368 * else: * inter = circle_segment(x1, y1, x2, y2) * pt1 = inter.p1 # <<<<<<<<<<<<<< * pt2 = inter.p2 * inter = circle_segment(x2, y2, x3, y3) */ __pyx_t_16 = __pyx_v_inter.p1; __pyx_v_pt1 = __pyx_t_16; /* "regions/_geometry/core.pyx":369 * inter = circle_segment(x1, y1, x2, y2) * pt1 = inter.p1 * pt2 = inter.p2 # <<<<<<<<<<<<<< * inter = circle_segment(x2, y2, x3, y3) * pt3 = inter.p1 */ __pyx_t_16 = __pyx_v_inter.p2; __pyx_v_pt2 = __pyx_t_16; /* "regions/_geometry/core.pyx":370 * pt1 = inter.p1 * pt2 = inter.p2 * inter = circle_segment(x2, y2, x3, y3) # <<<<<<<<<<<<<< * pt3 = inter.p1 * pt4 = inter.p2 */ __pyx_v_inter = __pyx_f_7regions_9_geometry_4core_circle_segment(__pyx_v_x2, __pyx_v_y2, __pyx_v_x3, __pyx_v_y3); /* "regions/_geometry/core.pyx":371 * pt2 = inter.p2 * inter = circle_segment(x2, y2, x3, y3) * pt3 = inter.p1 # <<<<<<<<<<<<<< * pt4 = inter.p2 * inter = circle_segment(x3, y3, x1, y1) */ __pyx_t_16 = __pyx_v_inter.p1; __pyx_v_pt3 = __pyx_t_16; /* "regions/_geometry/core.pyx":372 * inter = circle_segment(x2, y2, x3, y3) * pt3 = inter.p1 * pt4 = inter.p2 # <<<<<<<<<<<<<< * inter = circle_segment(x3, y3, x1, y1) * pt5 = inter.p1 */ __pyx_t_16 = __pyx_v_inter.p2; __pyx_v_pt4 = __pyx_t_16; /* "regions/_geometry/core.pyx":373 * pt3 = inter.p1 * pt4 = inter.p2 * inter = circle_segment(x3, y3, x1, y1) # <<<<<<<<<<<<<< * pt5 = inter.p1 * pt6 = inter.p2 */ __pyx_v_inter = __pyx_f_7regions_9_geometry_4core_circle_segment(__pyx_v_x3, __pyx_v_y3, __pyx_v_x1, __pyx_v_y1); /* "regions/_geometry/core.pyx":374 * pt4 = inter.p2 * inter = circle_segment(x3, y3, x1, y1) * pt5 = inter.p1 # <<<<<<<<<<<<<< * pt6 = inter.p2 * if pt1.x <= 1.: */ __pyx_t_16 = __pyx_v_inter.p1; __pyx_v_pt5 = __pyx_t_16; /* "regions/_geometry/core.pyx":375 * inter = circle_segment(x3, y3, x1, y1) * pt5 = inter.p1 * pt6 = inter.p2 # <<<<<<<<<<<<<< * if pt1.x <= 1.: * xp, yp = 0.5 * (pt1.x + pt2.x), 0.5 * (pt1.y + pt2.y) */ __pyx_t_16 = __pyx_v_inter.p2; __pyx_v_pt6 = __pyx_t_16; /* "regions/_geometry/core.pyx":376 * pt5 = inter.p1 * pt6 = inter.p2 * if pt1.x <= 1.: # <<<<<<<<<<<<<< * xp, yp = 0.5 * (pt1.x + pt2.x), 0.5 * (pt1.y + pt2.y) * area = overlap_area_triangle_unit_circle(x1, y1, x3, y3, xp, yp) \ */ __pyx_t_4 = ((__pyx_v_pt1.x <= 1.) != 0); if (__pyx_t_4) { /* "regions/_geometry/core.pyx":377 * pt6 = inter.p2 * if pt1.x <= 1.: * xp, yp = 0.5 * (pt1.x + pt2.x), 0.5 * (pt1.y + pt2.y) # <<<<<<<<<<<<<< * area = overlap_area_triangle_unit_circle(x1, y1, x3, y3, xp, yp) \ * + overlap_area_triangle_unit_circle(x2, y2, x3, y3, xp, yp) */ __pyx_t_6 = (0.5 * (__pyx_v_pt1.x + __pyx_v_pt2.x)); __pyx_t_5 = (0.5 * (__pyx_v_pt1.y + __pyx_v_pt2.y)); __pyx_v_xp = __pyx_t_6; __pyx_v_yp = __pyx_t_5; /* "regions/_geometry/core.pyx":379 * xp, yp = 0.5 * (pt1.x + pt2.x), 0.5 * (pt1.y + pt2.y) * area = overlap_area_triangle_unit_circle(x1, y1, x3, y3, xp, yp) \ * + overlap_area_triangle_unit_circle(x2, y2, x3, y3, xp, yp) # <<<<<<<<<<<<<< * elif pt3.x <= 1.: * xp, yp = 0.5 * (pt3.x + pt4.x), 0.5 * (pt3.y + pt4.y) */ __pyx_v_area = (__pyx_f_7regions_9_geometry_4core_overlap_area_triangle_unit_circle(__pyx_v_x1, __pyx_v_y1, __pyx_v_x3, __pyx_v_y3, __pyx_v_xp, __pyx_v_yp) + __pyx_f_7regions_9_geometry_4core_overlap_area_triangle_unit_circle(__pyx_v_x2, __pyx_v_y2, __pyx_v_x3, __pyx_v_y3, __pyx_v_xp, __pyx_v_yp)); /* "regions/_geometry/core.pyx":376 * pt5 = inter.p1 * pt6 = inter.p2 * if pt1.x <= 1.: # <<<<<<<<<<<<<< * xp, yp = 0.5 * (pt1.x + pt2.x), 0.5 * (pt1.y + pt2.y) * area = overlap_area_triangle_unit_circle(x1, y1, x3, y3, xp, yp) \ */ goto __pyx_L26; } /* "regions/_geometry/core.pyx":380 * area = overlap_area_triangle_unit_circle(x1, y1, x3, y3, xp, yp) \ * + overlap_area_triangle_unit_circle(x2, y2, x3, y3, xp, yp) * elif pt3.x <= 1.: # <<<<<<<<<<<<<< * xp, yp = 0.5 * (pt3.x + pt4.x), 0.5 * (pt3.y + pt4.y) * area = overlap_area_triangle_unit_circle(x3, y3, x1, y1, xp, yp) \ */ __pyx_t_4 = ((__pyx_v_pt3.x <= 1.) != 0); if (__pyx_t_4) { /* "regions/_geometry/core.pyx":381 * + overlap_area_triangle_unit_circle(x2, y2, x3, y3, xp, yp) * elif pt3.x <= 1.: * xp, yp = 0.5 * (pt3.x + pt4.x), 0.5 * (pt3.y + pt4.y) # <<<<<<<<<<<<<< * area = overlap_area_triangle_unit_circle(x3, y3, x1, y1, xp, yp) \ * + overlap_area_triangle_unit_circle(x2, y2, x1, y1, xp, yp) */ __pyx_t_5 = (0.5 * (__pyx_v_pt3.x + __pyx_v_pt4.x)); __pyx_t_6 = (0.5 * (__pyx_v_pt3.y + __pyx_v_pt4.y)); __pyx_v_xp = __pyx_t_5; __pyx_v_yp = __pyx_t_6; /* "regions/_geometry/core.pyx":383 * xp, yp = 0.5 * (pt3.x + pt4.x), 0.5 * (pt3.y + pt4.y) * area = overlap_area_triangle_unit_circle(x3, y3, x1, y1, xp, yp) \ * + overlap_area_triangle_unit_circle(x2, y2, x1, y1, xp, yp) # <<<<<<<<<<<<<< * elif pt5.x <= 1.: * xp, yp = 0.5 * (pt5.x + pt6.x), 0.5 * (pt5.y + pt6.y) */ __pyx_v_area = (__pyx_f_7regions_9_geometry_4core_overlap_area_triangle_unit_circle(__pyx_v_x3, __pyx_v_y3, __pyx_v_x1, __pyx_v_y1, __pyx_v_xp, __pyx_v_yp) + __pyx_f_7regions_9_geometry_4core_overlap_area_triangle_unit_circle(__pyx_v_x2, __pyx_v_y2, __pyx_v_x1, __pyx_v_y1, __pyx_v_xp, __pyx_v_yp)); /* "regions/_geometry/core.pyx":380 * area = overlap_area_triangle_unit_circle(x1, y1, x3, y3, xp, yp) \ * + overlap_area_triangle_unit_circle(x2, y2, x3, y3, xp, yp) * elif pt3.x <= 1.: # <<<<<<<<<<<<<< * xp, yp = 0.5 * (pt3.x + pt4.x), 0.5 * (pt3.y + pt4.y) * area = overlap_area_triangle_unit_circle(x3, y3, x1, y1, xp, yp) \ */ goto __pyx_L26; } /* "regions/_geometry/core.pyx":384 * area = overlap_area_triangle_unit_circle(x3, y3, x1, y1, xp, yp) \ * + overlap_area_triangle_unit_circle(x2, y2, x1, y1, xp, yp) * elif pt5.x <= 1.: # <<<<<<<<<<<<<< * xp, yp = 0.5 * (pt5.x + pt6.x), 0.5 * (pt5.y + pt6.y) * area = overlap_area_triangle_unit_circle(x1, y1, x2, y2, xp, yp) \ */ __pyx_t_4 = ((__pyx_v_pt5.x <= 1.) != 0); if (__pyx_t_4) { /* "regions/_geometry/core.pyx":385 * + overlap_area_triangle_unit_circle(x2, y2, x1, y1, xp, yp) * elif pt5.x <= 1.: * xp, yp = 0.5 * (pt5.x + pt6.x), 0.5 * (pt5.y + pt6.y) # <<<<<<<<<<<<<< * area = overlap_area_triangle_unit_circle(x1, y1, x2, y2, xp, yp) \ * + overlap_area_triangle_unit_circle(x3, y3, x2, y2, xp, yp) */ __pyx_t_6 = (0.5 * (__pyx_v_pt5.x + __pyx_v_pt6.x)); __pyx_t_5 = (0.5 * (__pyx_v_pt5.y + __pyx_v_pt6.y)); __pyx_v_xp = __pyx_t_6; __pyx_v_yp = __pyx_t_5; /* "regions/_geometry/core.pyx":387 * xp, yp = 0.5 * (pt5.x + pt6.x), 0.5 * (pt5.y + pt6.y) * area = overlap_area_triangle_unit_circle(x1, y1, x2, y2, xp, yp) \ * + overlap_area_triangle_unit_circle(x3, y3, x2, y2, xp, yp) # <<<<<<<<<<<<<< * else: # no intersections * if in_triangle(0., 0., x1, y1, x2, y2, x3, y3): */ __pyx_v_area = (__pyx_f_7regions_9_geometry_4core_overlap_area_triangle_unit_circle(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2, __pyx_v_xp, __pyx_v_yp) + __pyx_f_7regions_9_geometry_4core_overlap_area_triangle_unit_circle(__pyx_v_x3, __pyx_v_y3, __pyx_v_x2, __pyx_v_y2, __pyx_v_xp, __pyx_v_yp)); /* "regions/_geometry/core.pyx":384 * area = overlap_area_triangle_unit_circle(x3, y3, x1, y1, xp, yp) \ * + overlap_area_triangle_unit_circle(x2, y2, x1, y1, xp, yp) * elif pt5.x <= 1.: # <<<<<<<<<<<<<< * xp, yp = 0.5 * (pt5.x + pt6.x), 0.5 * (pt5.y + pt6.y) * area = overlap_area_triangle_unit_circle(x1, y1, x2, y2, xp, yp) \ */ goto __pyx_L26; } /* "regions/_geometry/core.pyx":389 * + overlap_area_triangle_unit_circle(x3, y3, x2, y2, xp, yp) * else: # no intersections * if in_triangle(0., 0., x1, y1, x2, y2, x3, y3): # <<<<<<<<<<<<<< * return PI * else: */ /*else*/ { __pyx_t_4 = (__pyx_f_7regions_9_geometry_4core_in_triangle(0., 0., __pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2, __pyx_v_x3, __pyx_v_y3) != 0); if (__pyx_t_4) { /* "regions/_geometry/core.pyx":390 * else: # no intersections * if in_triangle(0., 0., x1, y1, x2, y2, x3, y3): * return PI # <<<<<<<<<<<<<< * else: * return 0. */ __pyx_r = __pyx_v_PI; goto __pyx_L0; /* "regions/_geometry/core.pyx":389 * + overlap_area_triangle_unit_circle(x3, y3, x2, y2, xp, yp) * else: # no intersections * if in_triangle(0., 0., x1, y1, x2, y2, x3, y3): # <<<<<<<<<<<<<< * return PI * else: */ } /* "regions/_geometry/core.pyx":392 * return PI * else: * return 0. # <<<<<<<<<<<<<< * * return area */ /*else*/ { __pyx_r = 0.; goto __pyx_L0; } } __pyx_L26:; } __pyx_L10:; /* "regions/_geometry/core.pyx":394 * return 0. * * return area # <<<<<<<<<<<<<< */ __pyx_r = __pyx_v_area; goto __pyx_L0; /* "regions/_geometry/core.pyx":263 * * * cdef double overlap_area_triangle_unit_circle(double x1, double y1, double x2, double y2, double x3, double y3): # <<<<<<<<<<<<<< * """ * Given a triangle defined by three points (x1, y1), (x2, y2), and */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_WriteUnraisable("regions._geometry.core.overlap_area_triangle_unit_circle", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_in1); __Pyx_XDECREF((PyObject *)__pyx_v_in2); __Pyx_XDECREF((PyObject *)__pyx_v_in3); __Pyx_XDECREF((PyObject *)__pyx_v_on1); __Pyx_XDECREF((PyObject *)__pyx_v_on2); __Pyx_XDECREF((PyObject *)__pyx_v_on3); __Pyx_XDECREF(__pyx_v_intersect13); __Pyx_XDECREF(__pyx_v_intersect23); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< * # This implementation of getbuffer is geared towards Cython * # requirements, and does not yet fulfill the PEP. */ /* Python wrapper */ static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_v_i; int __pyx_v_ndim; int __pyx_v_endian_detector; int __pyx_v_little_endian; int __pyx_v_t; char *__pyx_v_f; PyArray_Descr *__pyx_v_descr = 0; int __pyx_v_offset; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyArray_Descr *__pyx_t_7; PyObject *__pyx_t_8 = NULL; char *__pyx_t_9; if (__pyx_v_info == NULL) { PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); return -1; } __Pyx_RefNannySetupContext("__getbuffer__", 0); __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 * * cdef int i, ndim * cdef int endian_detector = 1 # <<<<<<<<<<<<<< * cdef bint little_endian = ((&endian_detector)[0] != 0) * */ __pyx_v_endian_detector = 1; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 * cdef int i, ndim * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * * ndim = PyArray_NDIM(self) */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 * cdef bint little_endian = ((&endian_detector)[0] != 0) * * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) */ __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< * raise ValueError(u"ndarray is not C contiguous") * */ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 272, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L7_bool_binop_done; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< * raise ValueError(u"ndarray is not Fortran contiguous") * */ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L7_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 276, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 * raise ValueError(u"ndarray is not Fortran contiguous") * * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 * * info.buf = PyArray_DATA(self) * info.ndim = ndim # <<<<<<<<<<<<<< * if sizeof(npy_intp) != sizeof(Py_ssize_t): * # Allocate new buffer for strides and shape info. */ __pyx_v_info->ndim = __pyx_v_ndim; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. */ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< * info.shape = info.strides + ndim * for i in range(ndim): */ __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim # <<<<<<<<<<<<<< * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] */ __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim * for i in range(ndim): # <<<<<<<<<<<<<< * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] */ __pyx_t_4 = __pyx_v_ndim; __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286 * info.shape = info.strides + ndim * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< * info.shape[i] = PyArray_DIMS(self)[i] * else: */ (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287 * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< * else: * info.strides = PyArray_STRIDES(self) */ (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. */ goto __pyx_L9; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289 * info.shape[i] = PyArray_DIMS(self)[i] * else: * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL */ /*else*/ { __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 * else: * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) */ __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); } __pyx_L9:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL # <<<<<<<<<<<<<< * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) */ __pyx_v_info->suboffsets = NULL; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< * info.readonly = not PyArray_ISWRITEABLE(self) * */ __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< * * cdef int t */ __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296 * * cdef int t * cdef char* f = NULL # <<<<<<<<<<<<<< * cdef dtype descr = PyArray_DESCR(self) * cdef int offset */ __pyx_v_f = NULL; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297 * cdef int t * cdef char* f = NULL * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< * cdef int offset * */ __pyx_t_7 = PyArray_DESCR(__pyx_v_self); __pyx_t_3 = ((PyObject *)__pyx_t_7); __Pyx_INCREF(__pyx_t_3); __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300 * cdef int offset * * info.obj = self # <<<<<<<<<<<<<< * * if not PyDataType_HASFIELDS(descr): */ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or */ __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303 * * if not PyDataType_HASFIELDS(descr): * t = descr.type_num # <<<<<<<<<<<<<< * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): */ __pyx_t_4 = __pyx_v_descr->type_num; __pyx_v_t = __pyx_t_4; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); if (!__pyx_t_2) { goto __pyx_L15_next_or; } else { } __pyx_t_2 = (__pyx_v_little_endian != 0); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L14_bool_binop_done; } __pyx_L15_next_or:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305 * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" */ __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L14_bool_binop_done; } __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L14_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 306, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307 * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" */ switch (__pyx_v_t) { case NPY_BYTE: __pyx_v_f = ((char *)"b"); break; case NPY_UBYTE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308 * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" */ __pyx_v_f = ((char *)"B"); break; case NPY_SHORT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309 * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" */ __pyx_v_f = ((char *)"h"); break; case NPY_USHORT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310 * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" */ __pyx_v_f = ((char *)"H"); break; case NPY_INT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311 * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" */ __pyx_v_f = ((char *)"i"); break; case NPY_UINT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312 * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" */ __pyx_v_f = ((char *)"I"); break; case NPY_LONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313 * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" */ __pyx_v_f = ((char *)"l"); break; case NPY_ULONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314 * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" */ __pyx_v_f = ((char *)"L"); break; case NPY_LONGLONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315 * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" */ __pyx_v_f = ((char *)"q"); break; case NPY_ULONGLONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316 * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" */ __pyx_v_f = ((char *)"Q"); break; case NPY_FLOAT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317 * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" */ __pyx_v_f = ((char *)"f"); break; case NPY_DOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318 * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" */ __pyx_v_f = ((char *)"d"); break; case NPY_LONGDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319 * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" */ __pyx_v_f = ((char *)"g"); break; case NPY_CFLOAT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320 * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" */ __pyx_v_f = ((char *)"Zf"); break; case NPY_CDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321 * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" */ __pyx_v_f = ((char *)"Zd"); break; case NPY_CLONGDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322 * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f = "O" * else: */ __pyx_v_f = ((char *)"Zg"); break; case NPY_OBJECT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323 * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ __pyx_v_f = ((char *)"O"); break; default: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325 * elif t == NPY_OBJECT: f = "O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * info.format = f * return */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 325, __pyx_L1_error) break; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f # <<<<<<<<<<<<<< * return * else: */ __pyx_v_info->format = __pyx_v_f; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327 * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f * return # <<<<<<<<<<<<<< * else: * info.format = PyObject_Malloc(_buffer_format_string_len) */ __pyx_r = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329 * return * else: * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 */ /*else*/ { __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330 * else: * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< * offset = 0 * f = _util_dtypestring(descr, info.format + 1, */ (__pyx_v_info->format[0]) = '^'; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331 * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 # <<<<<<<<<<<<<< * f = _util_dtypestring(descr, info.format + 1, * info.format + _buffer_format_string_len, */ __pyx_v_offset = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332 * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< * info.format + _buffer_format_string_len, * &offset) */ __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error) __pyx_v_f = __pyx_t_9; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335 * info.format + _buffer_format_string_len, * &offset) * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< * * def __releasebuffer__(ndarray self, Py_buffer* info): */ (__pyx_v_f[0]) = '\x00'; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< * # This implementation of getbuffer is geared towards Cython * # requirements, and does not yet fulfill the PEP. */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; if (__pyx_v_info->obj != NULL) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } goto __pyx_L2; __pyx_L0:; if (__pyx_v_info->obj == Py_None) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_descr); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) */ /* Python wrapper */ static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__releasebuffer__", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339 * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) # <<<<<<<<<<<<<< * if sizeof(npy_intp) != sizeof(Py_ssize_t): * PyObject_Free(info.strides) */ PyObject_Free(__pyx_v_info->format); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * PyObject_Free(info.strides) * # info.shape was stored after info.strides in the same block */ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341 * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): * PyObject_Free(info.strides) # <<<<<<<<<<<<<< * # info.shape was stored after info.strides in the same block * */ PyObject_Free(__pyx_v_info->strides); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * PyObject_Free(info.strides) * # info.shape was stored after info.strides in the same block */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":825 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 828, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 831, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * * cdef inline tuple PyDataType_SHAPE(dtype d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< * else: * return () */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_empty_tuple); __pyx_r = __pyx_empty_tuple; goto __pyx_L0; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< * # Recursive utility function used in __getbuffer__ to get format * # string. The new location in the format string is returned. */ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { PyArray_Descr *__pyx_v_child = 0; int __pyx_v_endian_detector; int __pyx_v_little_endian; PyObject *__pyx_v_fields = 0; PyObject *__pyx_v_childname = NULL; PyObject *__pyx_v_new_offset = NULL; PyObject *__pyx_v_t = NULL; char *__pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; int __pyx_t_7; long __pyx_t_8; char *__pyx_t_9; __Pyx_RefNannySetupContext("_util_dtypestring", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847 * * cdef dtype child * cdef int endian_detector = 1 # <<<<<<<<<<<<<< * cdef bint little_endian = ((&endian_detector)[0] != 0) * cdef tuple fields */ __pyx_v_endian_detector = 1; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":848 * cdef dtype child * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * cdef tuple fields * */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< * fields = descr.fields[childname] * child, new_offset = fields */ if (unlikely(__pyx_v_descr->names == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(1, 851, __pyx_L1_error) } __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 851, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852 * * for childname in descr.names: * fields = descr.fields[childname] # <<<<<<<<<<<<<< * child, new_offset = fields * */ if (unlikely(__pyx_v_descr->fields == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 852, __pyx_L1_error) } __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":853 * for childname in descr.names: * fields = descr.fields[childname] * child, new_offset = fields # <<<<<<<<<<<<<< * * if (end - f) - (new_offset - offset[0]) < 15: */ if (likely(__pyx_v_fields != Py_None)) { PyObject* sequence = __pyx_v_fields; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(1, 853, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } else { __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 853, __pyx_L1_error) } if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); __pyx_t_4 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 856, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); if (!__pyx_t_7) { goto __pyx_L8_next_or; } else { } __pyx_t_7 = (__pyx_v_little_endian != 0); if (!__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_L8_next_or:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859 * * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< * raise ValueError(u"Non-native byte order not supported") * # One could encode it in the format string and have Cython */ __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); if (__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_6 = __pyx_t_7; __pyx_L7_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":860 * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * # One could encode it in the format string and have Cython * # complain instead, BUT: < and > in format strings also imply */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 860, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 860, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870 * * # Output padding bytes * while offset[0] < new_offset: # <<<<<<<<<<<<<< * f[0] = 120 # "x"; pad byte * f += 1 */ while (1) { __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_6) break; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871 * # Output padding bytes * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< * f += 1 * offset[0] += 1 */ (__pyx_v_f[0]) = 0x78; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872 * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte * f += 1 # <<<<<<<<<<<<<< * offset[0] += 1 * */ __pyx_v_f = (__pyx_v_f + 1); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":873 * f[0] = 120 # "x"; pad byte * f += 1 * offset[0] += 1 # <<<<<<<<<<<<<< * * offset[0] += child.itemsize */ __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":875 * offset[0] += 1 * * offset[0] += child.itemsize # <<<<<<<<<<<<<< * * if not PyDataType_HASFIELDS(child): */ __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< * t = child.type_num * if end - f < 5: */ __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); if (__pyx_t_6) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 * * if not PyDataType_HASFIELDS(child): * t = child.type_num # <<<<<<<<<<<<<< * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); __pyx_t_4 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short.") * */ __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 880, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short.") * */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883 * * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 98; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884 * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 66; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885 * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x68; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886 * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 72; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887 * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x69; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888 * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 73; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889 * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x6C; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890 * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 76; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891 * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x71; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892 * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 81; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893 * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x66; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894 * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x64; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895 * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x67; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896 * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x66; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897 * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x64; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898 * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x67; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":899 * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(__pyx_t_6)) { (__pyx_v_f[0]) = 79; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901 * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * f += 1 * else: */ /*else*/ { __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 901, __pyx_L1_error) } __pyx_L15:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":902 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * f += 1 # <<<<<<<<<<<<<< * else: * # Cython ignores struct boundary information ("T{...}"), */ __pyx_v_f = (__pyx_v_f + 1); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< * t = child.type_num * if end - f < 5: */ goto __pyx_L13; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906 * # Cython ignores struct boundary information ("T{...}"), * # so don't output it * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< * return f * */ /*else*/ { __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 906, __pyx_L1_error) __pyx_v_f = __pyx_t_9; } __pyx_L13:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< * fields = descr.fields[childname] * child, new_offset = fields */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":907 * # so don't output it * f = _util_dtypestring(child, f, end, offset) * return f # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_f; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< * # Recursive utility function used in __getbuffer__ to get format * # string. The new location in the format string is returned. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_child); __Pyx_XDECREF(__pyx_v_fields); __Pyx_XDECREF(__pyx_v_childname); __Pyx_XDECREF(__pyx_v_new_offset); __Pyx_XDECREF(__pyx_v_t); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< * PyArray_SetBaseObject(arr, base) * */ Py_INCREF(__pyx_v_base); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1024 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * * cdef inline object get_array_base(ndarray arr): */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< * if base is NULL: * return None */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< * return base * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1030 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< * * # Versions of the import_* functions which are more suitable for */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * _import_array() */ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_array", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036 * cdef inline int import_array() except -1: * try: * _import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1036, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 * try: * _import_array() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.multiarray failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1037, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1038, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1038, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * _import_array() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_umath", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1042, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1043, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1044, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1044, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_ufunc", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1048, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1049, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1050 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1050, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1050, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec_core(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_core}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "core", __pyx_k_The_functions_here_are_the_core, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_DTYPE, __pyx_k_DTYPE, sizeof(__pyx_k_DTYPE), 0, 0, 1, 1}, {&__pyx_kp_u_ERROR_vertices_did_not_sort_corr, __pyx_k_ERROR_vertices_did_not_sort_corr, sizeof(__pyx_k_ERROR_vertices_did_not_sort_corr), 0, 1, 0, 0}, {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_u_elliptical_overlap_grid, __pyx_k_elliptical_overlap_grid, sizeof(__pyx_k_elliptical_overlap_grid), 0, 1, 0, 1}, {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, {&__pyx_n_s_pi, __pyx_k_pi, sizeof(__pyx_k_pi), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(1, 285, __pyx_L1_error) __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 856, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1038, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "regions/_geometry/core.pyx":300 * * if d1 > d2 or d2 > d3 or d1 > d3: * raise Exception("ERROR: vertices did not sort correctly") # <<<<<<<<<<<<<< * * # Determine number of vertices inside circle */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_ERROR_vertices_did_not_sort_corr); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 300, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 1038, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 1044, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ if (__Pyx_ExportFunction("distance", (void (*)(void))__pyx_f_7regions_9_geometry_4core_distance, "double (double, double, double, double)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("area_arc", (void (*)(void))__pyx_f_7regions_9_geometry_4core_area_arc, "double (double, double, double, double, double)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("area_triangle", (void (*)(void))__pyx_f_7regions_9_geometry_4core_area_triangle, "double (double, double, double, double, double, double)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("area_arc_unit", (void (*)(void))__pyx_f_7regions_9_geometry_4core_area_arc_unit, "double (double, double, double, double)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("in_triangle", (void (*)(void))__pyx_f_7regions_9_geometry_4core_in_triangle, "int (double, double, double, double, double, double, double, double)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("overlap_area_triangle_unit_circle", (void (*)(void))__pyx_f_7regions_9_geometry_4core_overlap_area_triangle_unit_circle, "double (double, double, double, double, double, double)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("floor_sqrt", (void (*)(void))__pyx_f_7regions_9_geometry_4core_floor_sqrt, "double (double)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 sizeof(PyTypeObject), #else sizeof(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(3, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(4, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error) __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error) __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 918, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #if PY_MAJOR_VERSION < 3 #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC void #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #else #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyObject * #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC initcore(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC initcore(void) #else __Pyx_PyMODINIT_FUNC PyInit_core(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_core(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec_core(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module 'core' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_core(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("core", __pyx_methods, __pyx_k_The_functions_here_are_the_core, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_regions___geometry__core) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "regions._geometry.core")) { if (unlikely(PyDict_SetItemString(modules, "regions._geometry.core", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); if (unlikely(__Pyx_modinit_function_export_code() != 0)) goto __pyx_L1_error; (void)__Pyx_modinit_type_init_code(); if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error; (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "regions/_geometry/core.pyx":8 * unicode_literals) * * import numpy as np # <<<<<<<<<<<<<< * cimport numpy as np * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/core.pyx":12 * * * __all__ = ['elliptical_overlap_grid'] # <<<<<<<<<<<<<< * * */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_u_elliptical_overlap_grid); __Pyx_GIVEREF(__pyx_n_u_elliptical_overlap_grid); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_u_elliptical_overlap_grid); if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_t_1) < 0) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/core.pyx":25 * from cpython cimport bool * * DTYPE = np.float64 # <<<<<<<<<<<<<< * ctypedef np.float64_t DTYPE_t * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE, __pyx_t_2) < 0) __PYX_ERR(0, 25, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/core.pyx":1 * # Licensed under a 3-clause BSD style license - see LICENSE.rst # <<<<<<<<<<<<<< * # cython: language_level=3 * """The functions here are the core geometry functions.""" */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init regions._geometry.core", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init regions._geometry.core"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* WriteUnraisableException */ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback, CYTHON_UNUSED int nogil) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_PyThreadState_declare #ifdef WITH_THREAD PyGILState_STATE state; if (nogil) state = PyGILState_Ensure(); #ifdef _MSC_VER else state = (PyGILState_STATE)-1; #endif #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } #ifdef WITH_THREAD if (nogil) PyGILState_Release(state); #endif } /* None */ static CYTHON_INLINE long __Pyx_mod_long(long a, long b) { long r = a % b; r += ((r != 0) & ((r ^ b) < 0)) * b; return r; } /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* DictGetItem */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); if (unlikely(!value)) { if (!PyErr_Occurred()) { if (unlikely(PyTuple_Check(key))) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) { PyErr_SetObject(PyExc_KeyError, args); Py_DECREF(args); } } else { PyErr_SetObject(PyExc_KeyError, key); } } return NULL; } Py_INCREF(value); return value; } #endif /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* RaiseNoneIterError */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; #ifdef Py_LIMITED_API PyObject *py_basicsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #ifndef Py_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if ((size_t)basicsize < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(result); return NULL; } #endif /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.')) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return ::std::complex< float >(x, y); } #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return x + y*(__pyx_t_float_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { __pyx_t_float_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabsf(b.real) >= fabsf(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { float r = b.imag / b.real; float s = (float)(1.0) / (b.real + b.imag * r); return __pyx_t_float_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { float r = b.real / b.imag; float s = (float)(1.0) / (b.imag + b.real * r); return __pyx_t_float_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else { float denom = b.real * b.real + b.imag * b.imag; return __pyx_t_float_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrtf(z.real*z.real + z.imag*z.imag); #else return hypotf(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; float r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { float denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(a, a); case 3: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, a); case 4: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = powf(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2f(0.0, -1.0); } } else { r = __Pyx_c_abs_float(a); theta = atan2f(a.imag, a.real); } lnr = logf(r); z_r = expf(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cosf(z_theta); z.imag = z_r * sinf(z_theta); return z; } #endif #endif /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return ::std::complex< double >(x, y); } #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return x + y*(__pyx_t_double_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { __pyx_t_double_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabs(b.real) >= fabs(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { double r = b.imag / b.real; double s = (double)(1.0) / (b.real + b.imag * r); return __pyx_t_double_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { double r = b.real / b.imag; double s = (double)(1.0) / (b.imag + b.real * r); return __pyx_t_double_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else { double denom = b.real * b.real + b.imag * b.imag; return __pyx_t_double_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrt(z.real*z.real + z.imag*z.imag); #else return hypot(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; double r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { double denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(a, a); case 3: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, a); case 4: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = pow(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2(0.0, -1.0); } } else { r = __Pyx_c_abs_double(a); theta = atan2(a.imag, a.real); } lnr = log(r); z_r = exp(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cos(z_theta); z.imag = z_r * sin(z_theta); return z; } #endif #endif /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(enum NPY_TYPES) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(enum NPY_TYPES) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i= 0x02070000 cobj = PyCapsule_New(tmp.p, sig, 0); #else cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0); #endif if (!cobj) goto bad; if (PyDict_SetItemString(d, name, cobj) < 0) goto bad; Py_DECREF(cobj); Py_DECREF(d); return 0; bad: Py_XDECREF(cobj); Py_XDECREF(d); return -1; } /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ regions-0.4/regions/_geometry/core.pxd0000644000076600000240000000133613501414013020164 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst # cython: language_level=3 # This file is needed in order to be able to cimport functions into other Cython files cdef double distance(double x1, double y1, double x2, double y2) cdef double area_arc(double x1, double y1, double x2, double y2, double R) cdef double area_triangle(double x1, double y1, double x2, double y2, double x3, double y3) cdef double area_arc_unit(double x1, double y1, double x2, double y2) cdef int in_triangle(double x, double y, double x1, double y1, double x2, double y2, double x3, double y3) cdef double overlap_area_triangle_unit_circle(double x1, double y1, double x2, double y2, double x3, double y3) cdef double floor_sqrt(double x) regions-0.4/regions/_geometry/core.pyx0000644000076600000240000002773613501414013020225 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst # cython: language_level=3 """The functions here are the core geometry functions.""" from __future__ import (absolute_import, division, print_function, unicode_literals) import numpy as np cimport numpy as np __all__ = ['elliptical_overlap_grid'] cdef extern from "math.h": double asin(double x) double sin(double x) double cos(double x) double sqrt(double x) double fabs(double x) from cpython cimport bool DTYPE = np.float64 ctypedef np.float64_t DTYPE_t cimport cython ctypedef struct point: double x double y ctypedef struct intersections: point p1 point p2 cdef double floor_sqrt(double x): """ In some of the geometrical functions, we have to take the sqrt of a number and we know that the number should be >= 0. However, in some cases the value is e.g. -1e-10, but we want to treat it as zero, which is what this function does. Note that this does **not** check whether negative values are close or not to zero, so this should be used only in cases where the value is expected to be positive on paper. """ if x > 0: return sqrt(x) else: return 0 # NOTE: The following two functions use cdef because they are not intended to be # called from the Python code. Using def makes them callable from outside, but # also slower. Some functions currently return multiple values, and for those we # still use 'def' for now. cdef double distance(double x1, double y1, double x2, double y2): """ Distance between two points in two dimensions. Parameters ---------- x1, y1 : float The coordinates of the first point x2, y2 : float The coordinates of the second point Returns ------- d : float The Euclidean distance between the two points """ return sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) cdef double area_arc(double x1, double y1, double x2, double y2, double r): """ Area of a circle arc with radius r between points (x1, y1) and (x2, y2). References ---------- http://mathworld.wolfram.com/CircularSegment.html """ cdef double a, theta a = distance(x1, y1, x2, y2) theta = 2. * asin(0.5 * a / r) return 0.5 * r * r * (theta - sin(theta)) cdef double area_triangle(double x1, double y1, double x2, double y2, double x3, double y3): """ Area of a triangle defined by three vertices. """ return 0.5 * abs(x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) cdef double area_arc_unit(double x1, double y1, double x2, double y2): """ Area of a circle arc with radius R between points (x1, y1) and (x2, y2) References ---------- http://mathworld.wolfram.com/CircularSegment.html """ cdef double a, theta a = distance(x1, y1, x2, y2) theta = 2. * asin(0.5 * a) return 0.5 * (theta - sin(theta)) cdef int in_triangle(double x, double y, double x1, double y1, double x2, double y2, double x3, double y3): """ Check if a point (x,y) is inside a triangle """ cdef int c = 0 c += ((y1 > y) != (y2 > y) and x < (x2 - x1) * (y - y1) / (y2 - y1) + x1) c += ((y2 > y) != (y3 > y) and x < (x3 - x2) * (y - y2) / (y3 - y2) + x2) c += ((y3 > y) != (y1 > y) and x < (x1 - x3) * (y - y3) / (y1 - y3) + x3) return c % 2 == 1 cdef intersections circle_line(double x1, double y1, double x2, double y2): """Intersection of a line defined by two points with a unit circle""" cdef double a, b, delta, dx, dy cdef double tolerance = 1.e-10 cdef intersections inter dx = x2 - x1 dy = y2 - y1 if fabs(dx) < tolerance and fabs(dy) < tolerance: inter.p1.x = 2. inter.p1.y = 2. inter.p2.x = 2. inter.p2.y = 2. elif fabs(dx) > fabs(dy): # Find the slope and intercept of the line a = dy / dx b = y1 - a * x1 # Find the determinant of the quadratic equation delta = 1. + a * a - b * b if delta > 0.: # solutions exist delta = sqrt(delta) inter.p1.x = (- a * b - delta) / (1. + a * a) inter.p1.y = a * inter.p1.x + b inter.p2.x = (- a * b + delta) / (1. + a * a) inter.p2.y = a * inter.p2.x + b else: # no solution, return values > 1 inter.p1.x = 2. inter.p1.y = 2. inter.p2.x = 2. inter.p2.y = 2. else: # Find the slope and intercept of the line a = dx / dy b = x1 - a * y1 # Find the determinant of the quadratic equation delta = 1. + a * a - b * b if delta > 0.: # solutions exist delta = sqrt(delta) inter.p1.y = (- a * b - delta) / (1. + a * a) inter.p1.x = a * inter.p1.y + b inter.p2.y = (- a * b + delta) / (1. + a * a) inter.p2.x = a * inter.p2.y + b else: # no solution, return values > 1 inter.p1.x = 2. inter.p1.y = 2. inter.p2.x = 2. inter.p2.y = 2. return inter cdef point circle_segment_single2(double x1, double y1, double x2, double y2): """ The intersection of a line with the unit circle. The intersection the closest to (x2, y2) is chosen. """ cdef double dx1, dy1, dx2, dy2 cdef intersections inter cdef point pt1, pt2, pt inter = circle_line(x1, y1, x2, y2) pt1 = inter.p1 pt2 = inter.p2 # Can be optimized, but just checking for correctness right now dx1 = fabs(pt1.x - x2) dy1 = fabs(pt1.y - y2) dx2 = fabs(pt2.x - x2) dy2 = fabs(pt2.y - y2) if dx1 > dy1: # compare based on x-axis if dx1 > dx2: pt = pt2 else: pt = pt1 else: if dy1 > dy2: pt = pt2 else: pt = pt1 return pt cdef intersections circle_segment(double x1, double y1, double x2, double y2): """ Intersection(s) of a segment with the unit circle. Discard any solution not on the segment. """ cdef intersections inter, inter_new cdef point pt1, pt2 inter = circle_line(x1, y1, x2, y2) pt1 = inter.p1 pt2 = inter.p2 if (pt1.x > x1 and pt1.x > x2) or (pt1.x < x1 and pt1.x < x2) or (pt1.y > y1 and pt1.y > y2) or (pt1.y < y1 and pt1.y < y2): pt1.x, pt1.y = 2., 2. if (pt2.x > x1 and pt2.x > x2) or (pt2.x < x1 and pt2.x < x2) or (pt2.y > y1 and pt2.y > y2) or (pt2.y < y1 and pt2.y < y2): pt2.x, pt2.y = 2., 2. if pt1.x > 1. and pt2.x < 2.: inter_new.p1 = pt1 inter_new.p2 = pt2 else: inter_new.p1 = pt2 inter_new.p2 = pt1 return inter_new cdef double overlap_area_triangle_unit_circle(double x1, double y1, double x2, double y2, double x3, double y3): """ Given a triangle defined by three points (x1, y1), (x2, y2), and (x3, y3), find the area of overlap with the unit circle. """ cdef double d1, d2, d3 cdef bool in1, in2, in3 cdef bool on1, on2, on3 cdef double area cdef double PI = np.pi cdef intersections inter cdef point pt1, pt2, pt3, pt4, pt5, pt6, pt_tmp # Find distance of all vertices to circle center d1 = x1 * x1 + y1 * y1 d2 = x2 * x2 + y2 * y2 d3 = x3 * x3 + y3 * y3 # Order vertices by distance from origin if d1 < d2: if d2 < d3: pass elif d1 < d3: x2, y2, d2, x3, y3, d3 = x3, y3, d3, x2, y2, d2 else: x1, y1, d1, x2, y2, d2, x3, y3, d3 = x3, y3, d3, x1, y1, d1, x2, y2, d2 else: if d1 < d3: x1, y1, d1, x2, y2, d2 = x2, y2, d2, x1, y1, d1 elif d2 < d3: x1, y1, d1, x2, y2, d2, x3, y3, d3 = x2, y2, d2, x3, y3, d3, x1, y1, d1 else: x1, y1, d1, x2, y2, d2, x3, y3, d3 = x3, y3, d3, x2, y2, d2, x1, y1, d1 if d1 > d2 or d2 > d3 or d1 > d3: raise Exception("ERROR: vertices did not sort correctly") # Determine number of vertices inside circle in1 = d1 < 1 in2 = d2 < 1 in3 = d3 < 1 # Determine which vertices are on the circle on1 = fabs(d1 - 1) < 1.e-10 on2 = fabs(d2 - 1) < 1.e-10 on3 = fabs(d3 - 1) < 1.e-10 if on3 or in3: # triangle is completely in circle area = area_triangle(x1, y1, x2, y2, x3, y3) elif in2 or on2: # If vertex 1 or 2 are on the edge of the circle, then we use the dot # product to vertex 3 to determine whether an intersection takes place. intersect13 = not on1 or x1 * (x3 - x1) + y1 * (y3 - y1) < 0. intersect23 = not on2 or x2 * (x3 - x2) + y2 * (y3 - y2) < 0. if intersect13 and intersect23 and not on2: pt1 = circle_segment_single2(x1, y1, x3, y3) pt2 = circle_segment_single2(x2, y2, x3, y3) area = area_triangle(x1, y1, x2, y2, pt1.x, pt1.y) \ + area_triangle(x2, y2, pt1.x, pt1.y, pt2.x, pt2.y) \ + area_arc_unit(pt1.x, pt1.y, pt2.x, pt2.y) elif intersect13: pt1 = circle_segment_single2(x1, y1, x3, y3) area = area_triangle(x1, y1, x2, y2, pt1.x, pt1.y) \ + area_arc_unit(x2, y2, pt1.x, pt1.y) elif intersect23: pt2 = circle_segment_single2(x2, y2, x3, y3) area = area_triangle(x1, y1, x2, y2, pt2.x, pt2.y) \ + area_arc_unit(x1, y1, pt2.x, pt2.y) else: area = area_arc_unit(x1, y1, x2, y2) elif on1: # The triangle is outside the circle area = 0.0 elif in1: # Check for intersections of far side with circle inter = circle_segment(x2, y2, x3, y3) pt1 = inter.p1 pt2 = inter.p2 pt3 = circle_segment_single2(x1, y1, x2, y2) pt4 = circle_segment_single2(x1, y1, x3, y3) if pt1.x > 1.: # indicates no intersection # Code taken from `sep.h`. # TODO: use `sep` and get rid of this Cython code. if (((0.-pt3.y) * (pt4.x-pt3.x) > (pt4.y-pt3.y) * (0.-pt3.x)) != ((y1-pt3.y) * (pt4.x-pt3.x) > (pt4.y-pt3.y) * (x1-pt3.x))): area = area_triangle(x1, y1, pt3.x, pt3.y, pt4.x, pt4.y) \ + (PI - area_arc_unit(pt3.x, pt3.y, pt4.x, pt4.y)) else: area = area_triangle(x1, y1, pt3.x, pt3.y, pt4.x, pt4.y) \ + area_arc_unit(pt3.x, pt3.y, pt4.x, pt4.y) else: if (pt2.x - x2)**2 + (pt2.y - y2)**2 < (pt1.x - x2)**2 + (pt1.y - y2)**2: pt1, pt2 = pt2, pt1 area = area_triangle(x1, y1, pt3.x, pt3.y, pt1.x, pt1.y) \ + area_triangle(x1, y1, pt1.x, pt1.y, pt2.x, pt2.y) \ + area_triangle(x1, y1, pt2.x, pt2.y, pt4.x, pt4.y) \ + area_arc_unit(pt1.x, pt1.y, pt3.x, pt3.y) \ + area_arc_unit(pt2.x, pt2.y, pt4.x, pt4.y) else: inter = circle_segment(x1, y1, x2, y2) pt1 = inter.p1 pt2 = inter.p2 inter = circle_segment(x2, y2, x3, y3) pt3 = inter.p1 pt4 = inter.p2 inter = circle_segment(x3, y3, x1, y1) pt5 = inter.p1 pt6 = inter.p2 if pt1.x <= 1.: xp, yp = 0.5 * (pt1.x + pt2.x), 0.5 * (pt1.y + pt2.y) area = overlap_area_triangle_unit_circle(x1, y1, x3, y3, xp, yp) \ + overlap_area_triangle_unit_circle(x2, y2, x3, y3, xp, yp) elif pt3.x <= 1.: xp, yp = 0.5 * (pt3.x + pt4.x), 0.5 * (pt3.y + pt4.y) area = overlap_area_triangle_unit_circle(x3, y3, x1, y1, xp, yp) \ + overlap_area_triangle_unit_circle(x2, y2, x1, y1, xp, yp) elif pt5.x <= 1.: xp, yp = 0.5 * (pt5.x + pt6.x), 0.5 * (pt5.y + pt6.y) area = overlap_area_triangle_unit_circle(x1, y1, x2, y2, xp, yp) \ + overlap_area_triangle_unit_circle(x3, y3, x2, y2, xp, yp) else: # no intersections if in_triangle(0., 0., x1, y1, x2, y2, x3, y3): return PI else: return 0. return area regions-0.4/regions/_geometry/elliptical_overlap.c0000644000076600000240000134450413501657421022561 0ustar deilstaff00000000000000/* Generated by Cython 0.29.6 */ #define PY_SSIZE_T_CLEAN #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_6" #define CYTHON_HEX_VERSION 0x001D06F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #ifndef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #define PyObject_Unicode PyObject_Str #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_ERR(f_index, lineno, Ln_error) \ { \ __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__regions___geometry__elliptical_overlap #define __PYX_HAVE_API__regions___geometry__elliptical_overlap /* Early includes */ #include #include #include "numpy/arrayobject.h" #include "numpy/ufuncobject.h" #include "math.h" #include "pythread.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; /* Header.proto */ #if !defined(CYTHON_CCOMPLEX) #if defined(__cplusplus) #define CYTHON_CCOMPLEX 1 #elif defined(_Complex_I) #define CYTHON_CCOMPLEX 1 #else #define CYTHON_CCOMPLEX 0 #endif #endif #if CYTHON_CCOMPLEX #ifdef __cplusplus #include #else #include #endif #endif #if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) #undef _Complex_I #define _Complex_I 1.0fj #endif static const char *__pyx_f[] = { "regions/_geometry/elliptical_overlap.pyx", "__init__.pxd", "type.pxd", "bool.pxd", "complex.pxd", }; /* BufferFormatStructs.proto */ #define IS_UNSIGNED(type) (((type) -1) > 0) struct __Pyx_StructField_; #define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) typedef struct { const char* name; struct __Pyx_StructField_* fields; size_t size; size_t arraysize[8]; int ndim; char typegroup; char is_unsigned; int flags; } __Pyx_TypeInfo; typedef struct __Pyx_StructField_ { __Pyx_TypeInfo* type; const char* name; size_t offset; } __Pyx_StructField; typedef struct { __Pyx_StructField* field; size_t parent_offset; } __Pyx_BufFmt_StackElem; typedef struct { __Pyx_StructField root; __Pyx_BufFmt_StackElem* head; size_t fmt_offset; size_t new_count, enc_count; size_t struct_alignment; int is_complex; char enc_type; char new_packmode; char enc_packmode; char is_valid_array; } __Pyx_BufFmt_Context; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t */ typedef npy_int8 __pyx_t_5numpy_int8_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t */ typedef npy_int16 __pyx_t_5numpy_int16_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< * ctypedef npy_int64 int64_t * #ctypedef npy_int96 int96_t */ typedef npy_int32 __pyx_t_5numpy_int32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< * #ctypedef npy_int96 int96_t * #ctypedef npy_int128 int128_t */ typedef npy_int64 __pyx_t_5numpy_int64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< * ctypedef npy_uint64 uint64_t * #ctypedef npy_uint96 uint96_t */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":786 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< * #ctypedef npy_uint96 uint96_t * #ctypedef npy_uint128 uint128_t */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< * ctypedef npy_float64 float64_t * #ctypedef npy_float80 float80_t */ typedef npy_float32 __pyx_t_5numpy_float32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< * #ctypedef npy_float80 float80_t * #ctypedef npy_float128 float128_t */ typedef npy_float64 __pyx_t_5numpy_float64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t */ typedef npy_long __pyx_t_5numpy_int_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< * ctypedef npy_longlong longlong_t * */ typedef npy_longlong __pyx_t_5numpy_long_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< * * ctypedef npy_ulong uint_t */ typedef npy_longlong __pyx_t_5numpy_longlong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t */ typedef npy_ulong __pyx_t_5numpy_uint_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulonglong_t * */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":806 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< * * ctypedef npy_intp intp_t */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< * ctypedef npy_uintp uintp_t * */ typedef npy_intp __pyx_t_5numpy_intp_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":809 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< * * ctypedef npy_double float_t */ typedef npy_uintp __pyx_t_5numpy_uintp_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t */ typedef npy_double __pyx_t_5numpy_float_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< * ctypedef npy_longdouble longdouble_t * */ typedef npy_double __pyx_t_5numpy_double_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cfloat cfloat_t */ typedef npy_longdouble __pyx_t_5numpy_longdouble_t; /* "regions/_geometry/elliptical_overlap.pyx":31 * * DTYPE = np.float64 * ctypedef np.float64_t DTYPE_t # <<<<<<<<<<<<<< * * cimport cython */ typedef __pyx_t_5numpy_float64_t __pyx_t_7regions_9_geometry_18elliptical_overlap_DTYPE_t; /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< float > __pyx_t_float_complex; #else typedef float _Complex __pyx_t_float_complex; #endif #else typedef struct { float real, imag; } __pyx_t_float_complex; #endif static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< double > __pyx_t_double_complex; #else typedef double _Complex __pyx_t_double_complex; #endif #else typedef struct { double real, imag; } __pyx_t_double_complex; #endif static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); /*--- Type declarations ---*/ /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< * ctypedef npy_clongdouble clongdouble_t * */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":817 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cdouble complex_t */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":819 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew1(a): */ typedef npy_cdouble __pyx_t_5numpy_complex_t; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* IsLittleEndian.proto */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); /* BufferFormatCheck.proto */ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type); /* BufferGetAndValidate.proto */ #define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ ((obj == Py_None || obj == NULL) ?\ (__Pyx_ZeroBuffer(buf), 0) :\ __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); static void __Pyx_ZeroBuffer(Py_buffer* buf); static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; /* BufferIndexError.proto */ static void __Pyx_RaiseBufferIndexError(int axis); #define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1) /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto #define __PYX_HAVE_RT_ImportType_proto enum __Pyx_ImportType_CheckSize { __Pyx_ImportType_CheckSize_Error = 0, __Pyx_ImportType_CheckSize_Warn = 1, __Pyx_ImportType_CheckSize_Ignore = 2 }; static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* BufferStructDeclare.proto */ typedef struct { Py_ssize_t shape, strides, suboffsets; } __Pyx_Buf_DimInfo; typedef struct { size_t refcount; Py_buffer pybuffer; } __Pyx_Buffer; typedef struct { __Pyx_Buffer *rcbuffer; char *data; __Pyx_Buf_DimInfo diminfo[8]; } __Pyx_LocalBuf_ND; #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); static void __Pyx_ReleaseBuffer(Py_buffer *view); #else #define __Pyx_GetBuffer PyObject_GetBuffer #define __Pyx_ReleaseBuffer PyBuffer_Release #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus #define __Pyx_CREAL(z) ((z).real()) #define __Pyx_CIMAG(z) ((z).imag()) #else #define __Pyx_CREAL(z) (__real__(z)) #define __Pyx_CIMAG(z) (__imag__(z)) #endif #else #define __Pyx_CREAL(z) ((z).real) #define __Pyx_CIMAG(z) ((z).imag) #endif #if defined(__cplusplus) && CYTHON_CCOMPLEX\ && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) #define __Pyx_SET_CREAL(z,x) ((z).real(x)) #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) #else #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_float(a, b) ((a)==(b)) #define __Pyx_c_sum_float(a, b) ((a)+(b)) #define __Pyx_c_diff_float(a, b) ((a)-(b)) #define __Pyx_c_prod_float(a, b) ((a)*(b)) #define __Pyx_c_quot_float(a, b) ((a)/(b)) #define __Pyx_c_neg_float(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_float(z) ((z)==(float)0) #define __Pyx_c_conj_float(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_float(z) (::std::abs(z)) #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_float(z) ((z)==0) #define __Pyx_c_conj_float(z) (conjf(z)) #if 1 #define __Pyx_c_abs_float(z) (cabsf(z)) #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); #endif #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_double(a, b) ((a)==(b)) #define __Pyx_c_sum_double(a, b) ((a)+(b)) #define __Pyx_c_diff_double(a, b) ((a)-(b)) #define __Pyx_c_prod_double(a, b) ((a)*(b)) #define __Pyx_c_quot_double(a, b) ((a)/(b)) #define __Pyx_c_neg_double(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_double(z) ((z)==(double)0) #define __Pyx_c_conj_double(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_double(z) (::std::abs(z)) #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_double(z) ((z)==0) #define __Pyx_c_conj_double(z) (conj(z)) #if 1 #define __Pyx_c_abs_double(z) (cabs(z)) #define __Pyx_c_pow_double(a, b) (cpow(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); #endif #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* FunctionImport.proto */ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'cpython.buffer' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdio' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.type' */ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; /* Module declarations from 'cpython.version' */ /* Module declarations from 'cpython.exc' */ /* Module declarations from 'cpython.module' */ /* Module declarations from 'cpython.mem' */ /* Module declarations from 'cpython.tuple' */ /* Module declarations from 'cpython.list' */ /* Module declarations from 'cpython.sequence' */ /* Module declarations from 'cpython.mapping' */ /* Module declarations from 'cpython.iterator' */ /* Module declarations from 'cpython.number' */ /* Module declarations from 'cpython.int' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.bool' */ static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; /* Module declarations from 'cpython.long' */ /* Module declarations from 'cpython.float' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.complex' */ static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; /* Module declarations from 'cpython.string' */ /* Module declarations from 'cpython.unicode' */ /* Module declarations from 'cpython.dict' */ /* Module declarations from 'cpython.instance' */ /* Module declarations from 'cpython.function' */ /* Module declarations from 'cpython.method' */ /* Module declarations from 'cpython.weakref' */ /* Module declarations from 'cpython.getargs' */ /* Module declarations from 'cpython.pythread' */ /* Module declarations from 'cpython.pystate' */ /* Module declarations from 'cpython.cobject' */ /* Module declarations from 'cpython.oldbuffer' */ /* Module declarations from 'cpython.set' */ /* Module declarations from 'cpython.bytes' */ /* Module declarations from 'cpython.pycapsule' */ /* Module declarations from 'cpython' */ /* Module declarations from 'cpython.object' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'numpy' */ /* Module declarations from 'numpy' */ static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ /* Module declarations from 'cython' */ /* Module declarations from 'regions._geometry.core' */ static double (*__pyx_f_7regions_9_geometry_4core_distance)(double, double, double, double); /*proto*/ static double (*__pyx_f_7regions_9_geometry_4core_area_triangle)(double, double, double, double, double, double); /*proto*/ static double (*__pyx_f_7regions_9_geometry_4core_overlap_area_triangle_unit_circle)(double, double, double, double, double, double); /*proto*/ /* Module declarations from 'regions._geometry.elliptical_overlap' */ static double __pyx_f_7regions_9_geometry_18elliptical_overlap_elliptical_overlap_single_subpixel(double, double, double, double, double, double, double, int); /*proto*/ static double __pyx_f_7regions_9_geometry_18elliptical_overlap_elliptical_overlap_single_exact(double, double, double, double, double, double, double); /*proto*/ static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_18elliptical_overlap_DTYPE_t = { "DTYPE_t", NULL, sizeof(__pyx_t_7regions_9_geometry_18elliptical_overlap_DTYPE_t), { 0 }, 0, 'R', 0, 0 }; #define __Pyx_MODULE_NAME "regions._geometry.elliptical_overlap" extern int __pyx_module_is_main_regions___geometry__elliptical_overlap; int __pyx_module_is_main_regions___geometry__elliptical_overlap = 0; /* Implementation of 'regions._geometry.elliptical_overlap' */ static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_ImportError; static const char __pyx_k_i[] = "i"; static const char __pyx_k_j[] = "j"; static const char __pyx_k_r[] = "r"; static const char __pyx_k_x[] = "x"; static const char __pyx_k_y[] = "y"; static const char __pyx_k_dx[] = "dx"; static const char __pyx_k_dy[] = "dy"; static const char __pyx_k_np[] = "np"; static const char __pyx_k_nx[] = "nx"; static const char __pyx_k_ny[] = "ny"; static const char __pyx_k_rx[] = "rx"; static const char __pyx_k_ry[] = "ry"; static const char __pyx_k_all[] = "__all__"; static const char __pyx_k_frac[] = "frac"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_norm[] = "norm"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_xmax[] = "xmax"; static const char __pyx_k_xmin[] = "xmin"; static const char __pyx_k_ymax[] = "ymax"; static const char __pyx_k_ymin[] = "ymin"; static const char __pyx_k_DTYPE[] = "DTYPE"; static const char __pyx_k_bxmax[] = "bxmax"; static const char __pyx_k_bxmin[] = "bxmin"; static const char __pyx_k_bymax[] = "bymax"; static const char __pyx_k_bymin[] = "bymin"; static const char __pyx_k_dtype[] = "dtype"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_pxmax[] = "pxmax"; static const char __pyx_k_pxmin[] = "pxmin"; static const char __pyx_k_pymax[] = "pymax"; static const char __pyx_k_pymin[] = "pymin"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_theta[] = "theta"; static const char __pyx_k_zeros[] = "zeros"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_float64[] = "float64"; static const char __pyx_k_subpixels[] = "subpixels"; static const char __pyx_k_use_exact[] = "use_exact"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_RuntimeError[] = "RuntimeError"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_elliptical_overlap_grid[] = "elliptical_overlap_grid"; static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; static const char __pyx_k_The_functions_defined_here_allo[] = "\nThe functions defined here allow one to determine the exact area of\noverlap of an ellipse and a triangle (written by Thomas Robitaille).\nThe approach is to divide the rectangle into two triangles, and\nreproject these so that the ellipse is a unit circle, then compute the\nintersection of a triangle with a unit circle.\n"; static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; static const char __pyx_k_regions__geometry_elliptical_ove[] = "regions/_geometry/elliptical_overlap.pyx"; static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; static const char __pyx_k_regions__geometry_elliptical_ove_2[] = "regions._geometry.elliptical_overlap"; static PyObject *__pyx_n_s_DTYPE; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; static PyObject *__pyx_n_s_RuntimeError; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_all; static PyObject *__pyx_n_s_bxmax; static PyObject *__pyx_n_s_bxmin; static PyObject *__pyx_n_s_bymax; static PyObject *__pyx_n_s_bymin; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_dx; static PyObject *__pyx_n_s_dy; static PyObject *__pyx_n_s_elliptical_overlap_grid; static PyObject *__pyx_n_u_elliptical_overlap_grid; static PyObject *__pyx_n_s_float64; static PyObject *__pyx_n_s_frac; static PyObject *__pyx_n_s_i; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_j; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_name; static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; static PyObject *__pyx_n_s_norm; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; static PyObject *__pyx_n_s_nx; static PyObject *__pyx_n_s_ny; static PyObject *__pyx_n_s_pxmax; static PyObject *__pyx_n_s_pxmin; static PyObject *__pyx_n_s_pymax; static PyObject *__pyx_n_s_pymin; static PyObject *__pyx_n_s_r; static PyObject *__pyx_n_s_range; static PyObject *__pyx_kp_s_regions__geometry_elliptical_ove; static PyObject *__pyx_n_s_regions__geometry_elliptical_ove_2; static PyObject *__pyx_n_s_rx; static PyObject *__pyx_n_s_ry; static PyObject *__pyx_n_s_subpixels; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_theta; static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; static PyObject *__pyx_n_s_use_exact; static PyObject *__pyx_n_s_x; static PyObject *__pyx_n_s_xmax; static PyObject *__pyx_n_s_xmin; static PyObject *__pyx_n_s_y; static PyObject *__pyx_n_s_ymax; static PyObject *__pyx_n_s_ymin; static PyObject *__pyx_n_s_zeros; static PyObject *__pyx_pf_7regions_9_geometry_18elliptical_overlap_elliptical_overlap_grid(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_xmin, double __pyx_v_xmax, double __pyx_v_ymin, double __pyx_v_ymax, int __pyx_v_nx, int __pyx_v_ny, double __pyx_v_rx, double __pyx_v_ry, double __pyx_v_theta, int __pyx_v_use_exact, int __pyx_v_subpixels); /* proto */ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_codeobj__9; /* Late includes */ /* "regions/_geometry/elliptical_overlap.pyx":41 * * * def elliptical_overlap_grid(double xmin, double xmax, double ymin, double ymax, # <<<<<<<<<<<<<< * int nx, int ny, double rx, double ry, double theta, * int use_exact, int subpixels): */ /* Python wrapper */ static PyObject *__pyx_pw_7regions_9_geometry_18elliptical_overlap_1elliptical_overlap_grid(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7regions_9_geometry_18elliptical_overlap_elliptical_overlap_grid[] = "\n elliptical_overlap_grid(xmin, xmax, ymin, ymax, nx, ny, rx, ry,\n use_exact, subpixels)\n\n Area of overlap between an ellipse and a pixel grid. The ellipse is\n centered on the origin.\n\n Parameters\n ----------\n xmin, xmax, ymin, ymax : float\n Extent of the grid in the x and y direction.\n nx, ny : int\n Grid dimensions.\n rx : float\n The width axis of the ellipse (without rotation).\n ry : float\n The height axis of the ellipse (without rotation).\n theta : float\n The rotation of the ellipse in radians (counterclockwise).\n use_exact : 0 or 1\n If set to 1, calculates the exact overlap, while if set to 0, uses a\n subpixel sampling method with ``subpixel`` subpixels in each direction.\n subpixels : int\n If ``use_exact`` is 0, each pixel is resampled by this factor in each\n dimension. Thus, each pixel is divided into ``subpixels ** 2``\n subpixels.\n\n Returns\n -------\n frac : `~numpy.ndarray`\n 2-d array giving the fraction of the overlap.\n "; static PyMethodDef __pyx_mdef_7regions_9_geometry_18elliptical_overlap_1elliptical_overlap_grid = {"elliptical_overlap_grid", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7regions_9_geometry_18elliptical_overlap_1elliptical_overlap_grid, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7regions_9_geometry_18elliptical_overlap_elliptical_overlap_grid}; static PyObject *__pyx_pw_7regions_9_geometry_18elliptical_overlap_1elliptical_overlap_grid(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { double __pyx_v_xmin; double __pyx_v_xmax; double __pyx_v_ymin; double __pyx_v_ymax; int __pyx_v_nx; int __pyx_v_ny; double __pyx_v_rx; double __pyx_v_ry; double __pyx_v_theta; int __pyx_v_use_exact; int __pyx_v_subpixels; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("elliptical_overlap_grid (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_xmin,&__pyx_n_s_xmax,&__pyx_n_s_ymin,&__pyx_n_s_ymax,&__pyx_n_s_nx,&__pyx_n_s_ny,&__pyx_n_s_rx,&__pyx_n_s_ry,&__pyx_n_s_theta,&__pyx_n_s_use_exact,&__pyx_n_s_subpixels,0}; PyObject* values[11] = {0,0,0,0,0,0,0,0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); CYTHON_FALLTHROUGH; case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); CYTHON_FALLTHROUGH; case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); CYTHON_FALLTHROUGH; case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); CYTHON_FALLTHROUGH; case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); CYTHON_FALLTHROUGH; case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xmin)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xmax)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("elliptical_overlap_grid", 1, 11, 11, 1); __PYX_ERR(0, 41, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ymin)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("elliptical_overlap_grid", 1, 11, 11, 2); __PYX_ERR(0, 41, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ymax)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("elliptical_overlap_grid", 1, 11, 11, 3); __PYX_ERR(0, 41, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nx)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("elliptical_overlap_grid", 1, 11, 11, 4); __PYX_ERR(0, 41, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ny)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("elliptical_overlap_grid", 1, 11, 11, 5); __PYX_ERR(0, 41, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 6: if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rx)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("elliptical_overlap_grid", 1, 11, 11, 6); __PYX_ERR(0, 41, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 7: if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ry)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("elliptical_overlap_grid", 1, 11, 11, 7); __PYX_ERR(0, 41, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 8: if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_theta)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("elliptical_overlap_grid", 1, 11, 11, 8); __PYX_ERR(0, 41, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 9: if (likely((values[9] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_use_exact)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("elliptical_overlap_grid", 1, 11, 11, 9); __PYX_ERR(0, 41, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 10: if (likely((values[10] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_subpixels)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("elliptical_overlap_grid", 1, 11, 11, 10); __PYX_ERR(0, 41, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "elliptical_overlap_grid") < 0)) __PYX_ERR(0, 41, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 11) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); values[4] = PyTuple_GET_ITEM(__pyx_args, 4); values[5] = PyTuple_GET_ITEM(__pyx_args, 5); values[6] = PyTuple_GET_ITEM(__pyx_args, 6); values[7] = PyTuple_GET_ITEM(__pyx_args, 7); values[8] = PyTuple_GET_ITEM(__pyx_args, 8); values[9] = PyTuple_GET_ITEM(__pyx_args, 9); values[10] = PyTuple_GET_ITEM(__pyx_args, 10); } __pyx_v_xmin = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_xmin == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 41, __pyx_L3_error) __pyx_v_xmax = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_xmax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 41, __pyx_L3_error) __pyx_v_ymin = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_ymin == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 41, __pyx_L3_error) __pyx_v_ymax = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_ymax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 41, __pyx_L3_error) __pyx_v_nx = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_nx == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 42, __pyx_L3_error) __pyx_v_ny = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_ny == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 42, __pyx_L3_error) __pyx_v_rx = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_rx == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 42, __pyx_L3_error) __pyx_v_ry = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_ry == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 42, __pyx_L3_error) __pyx_v_theta = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_theta == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 42, __pyx_L3_error) __pyx_v_use_exact = __Pyx_PyInt_As_int(values[9]); if (unlikely((__pyx_v_use_exact == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 43, __pyx_L3_error) __pyx_v_subpixels = __Pyx_PyInt_As_int(values[10]); if (unlikely((__pyx_v_subpixels == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 43, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("elliptical_overlap_grid", 1, 11, 11, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 41, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("regions._geometry.elliptical_overlap.elliptical_overlap_grid", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7regions_9_geometry_18elliptical_overlap_elliptical_overlap_grid(__pyx_self, __pyx_v_xmin, __pyx_v_xmax, __pyx_v_ymin, __pyx_v_ymax, __pyx_v_nx, __pyx_v_ny, __pyx_v_rx, __pyx_v_ry, __pyx_v_theta, __pyx_v_use_exact, __pyx_v_subpixels); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7regions_9_geometry_18elliptical_overlap_elliptical_overlap_grid(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_xmin, double __pyx_v_xmax, double __pyx_v_ymin, double __pyx_v_ymax, int __pyx_v_nx, int __pyx_v_ny, double __pyx_v_rx, double __pyx_v_ry, double __pyx_v_theta, int __pyx_v_use_exact, int __pyx_v_subpixels) { unsigned int __pyx_v_i; unsigned int __pyx_v_j; double __pyx_v_dx; double __pyx_v_dy; double __pyx_v_bxmin; double __pyx_v_bxmax; double __pyx_v_bymin; double __pyx_v_bymax; double __pyx_v_pxmin; double __pyx_v_pxmax; double __pyx_v_pymin; double __pyx_v_pymax; double __pyx_v_norm; PyArrayObject *__pyx_v_frac = 0; double __pyx_v_r; __Pyx_LocalBuf_ND __pyx_pybuffernd_frac; __Pyx_Buffer __pyx_pybuffer_frac; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyArrayObject *__pyx_t_5 = NULL; double __pyx_t_6; double __pyx_t_7; double __pyx_t_8; int __pyx_t_9; int __pyx_t_10; unsigned int __pyx_t_11; int __pyx_t_12; int __pyx_t_13; int __pyx_t_14; int __pyx_t_15; unsigned int __pyx_t_16; size_t __pyx_t_17; size_t __pyx_t_18; int __pyx_t_19; size_t __pyx_t_20; size_t __pyx_t_21; __Pyx_RefNannySetupContext("elliptical_overlap_grid", 0); __pyx_pybuffer_frac.pybuffer.buf = NULL; __pyx_pybuffer_frac.refcount = 0; __pyx_pybuffernd_frac.data = NULL; __pyx_pybuffernd_frac.rcbuffer = &__pyx_pybuffer_frac; /* "regions/_geometry/elliptical_overlap.pyx":84 * * # Define output array * cdef np.ndarray[DTYPE_t, ndim=2] frac = np.zeros([ny, nx], dtype=DTYPE) # <<<<<<<<<<<<<< * * # Find the width of each element in x and y */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_ny); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_nx); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_3); PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 84, __pyx_L1_error) __pyx_t_5 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_frac.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_18elliptical_overlap_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) { __pyx_v_frac = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_frac.rcbuffer->pybuffer.buf = NULL; __PYX_ERR(0, 84, __pyx_L1_error) } else {__pyx_pybuffernd_frac.diminfo[0].strides = __pyx_pybuffernd_frac.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_frac.diminfo[0].shape = __pyx_pybuffernd_frac.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_frac.diminfo[1].strides = __pyx_pybuffernd_frac.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_frac.diminfo[1].shape = __pyx_pybuffernd_frac.rcbuffer->pybuffer.shape[1]; } } __pyx_t_5 = 0; __pyx_v_frac = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/elliptical_overlap.pyx":87 * * # Find the width of each element in x and y * dx = (xmax - xmin) / nx # <<<<<<<<<<<<<< * dy = (ymax - ymin) / ny * */ __pyx_t_6 = (__pyx_v_xmax - __pyx_v_xmin); if (unlikely(__pyx_v_nx == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 87, __pyx_L1_error) } __pyx_v_dx = (__pyx_t_6 / ((double)__pyx_v_nx)); /* "regions/_geometry/elliptical_overlap.pyx":88 * # Find the width of each element in x and y * dx = (xmax - xmin) / nx * dy = (ymax - ymin) / ny # <<<<<<<<<<<<<< * * norm = 1. / (dx * dy) */ __pyx_t_6 = (__pyx_v_ymax - __pyx_v_ymin); if (unlikely(__pyx_v_ny == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 88, __pyx_L1_error) } __pyx_v_dy = (__pyx_t_6 / ((double)__pyx_v_ny)); /* "regions/_geometry/elliptical_overlap.pyx":90 * dy = (ymax - ymin) / ny * * norm = 1. / (dx * dy) # <<<<<<<<<<<<<< * * # For now we use a bounding circle and then use that to find a bounding box */ __pyx_t_6 = (__pyx_v_dx * __pyx_v_dy); if (unlikely(__pyx_t_6 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 90, __pyx_L1_error) } __pyx_v_norm = (1. / __pyx_t_6); /* "regions/_geometry/elliptical_overlap.pyx":96 * * # Find bounding circle radius * r = max(rx, ry) # <<<<<<<<<<<<<< * * # Define bounding box */ __pyx_t_6 = __pyx_v_ry; __pyx_t_7 = __pyx_v_rx; if (((__pyx_t_6 > __pyx_t_7) != 0)) { __pyx_t_8 = __pyx_t_6; } else { __pyx_t_8 = __pyx_t_7; } __pyx_v_r = __pyx_t_8; /* "regions/_geometry/elliptical_overlap.pyx":99 * * # Define bounding box * bxmin = -r - 0.5 * dx # <<<<<<<<<<<<<< * bxmax = +r + 0.5 * dx * bymin = -r - 0.5 * dy */ __pyx_v_bxmin = ((-__pyx_v_r) - (0.5 * __pyx_v_dx)); /* "regions/_geometry/elliptical_overlap.pyx":100 * # Define bounding box * bxmin = -r - 0.5 * dx * bxmax = +r + 0.5 * dx # <<<<<<<<<<<<<< * bymin = -r - 0.5 * dy * bymax = +r + 0.5 * dy */ __pyx_v_bxmax = (__pyx_v_r + (0.5 * __pyx_v_dx)); /* "regions/_geometry/elliptical_overlap.pyx":101 * bxmin = -r - 0.5 * dx * bxmax = +r + 0.5 * dx * bymin = -r - 0.5 * dy # <<<<<<<<<<<<<< * bymax = +r + 0.5 * dy * */ __pyx_v_bymin = ((-__pyx_v_r) - (0.5 * __pyx_v_dy)); /* "regions/_geometry/elliptical_overlap.pyx":102 * bxmax = +r + 0.5 * dx * bymin = -r - 0.5 * dy * bymax = +r + 0.5 * dy # <<<<<<<<<<<<<< * * for i in range(nx): */ __pyx_v_bymax = (__pyx_v_r + (0.5 * __pyx_v_dy)); /* "regions/_geometry/elliptical_overlap.pyx":104 * bymax = +r + 0.5 * dy * * for i in range(nx): # <<<<<<<<<<<<<< * pxmin = xmin + i * dx # lower end of pixel * pxmax = pxmin + dx # upper end of pixel */ __pyx_t_9 = __pyx_v_nx; __pyx_t_10 = __pyx_t_9; for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_i = __pyx_t_11; /* "regions/_geometry/elliptical_overlap.pyx":105 * * for i in range(nx): * pxmin = xmin + i * dx # lower end of pixel # <<<<<<<<<<<<<< * pxmax = pxmin + dx # upper end of pixel * if pxmax > bxmin and pxmin < bxmax: */ __pyx_v_pxmin = (__pyx_v_xmin + (__pyx_v_i * __pyx_v_dx)); /* "regions/_geometry/elliptical_overlap.pyx":106 * for i in range(nx): * pxmin = xmin + i * dx # lower end of pixel * pxmax = pxmin + dx # upper end of pixel # <<<<<<<<<<<<<< * if pxmax > bxmin and pxmin < bxmax: * for j in range(ny): */ __pyx_v_pxmax = (__pyx_v_pxmin + __pyx_v_dx); /* "regions/_geometry/elliptical_overlap.pyx":107 * pxmin = xmin + i * dx # lower end of pixel * pxmax = pxmin + dx # upper end of pixel * if pxmax > bxmin and pxmin < bxmax: # <<<<<<<<<<<<<< * for j in range(ny): * pymin = ymin + j * dy */ __pyx_t_13 = ((__pyx_v_pxmax > __pyx_v_bxmin) != 0); if (__pyx_t_13) { } else { __pyx_t_12 = __pyx_t_13; goto __pyx_L6_bool_binop_done; } __pyx_t_13 = ((__pyx_v_pxmin < __pyx_v_bxmax) != 0); __pyx_t_12 = __pyx_t_13; __pyx_L6_bool_binop_done:; if (__pyx_t_12) { /* "regions/_geometry/elliptical_overlap.pyx":108 * pxmax = pxmin + dx # upper end of pixel * if pxmax > bxmin and pxmin < bxmax: * for j in range(ny): # <<<<<<<<<<<<<< * pymin = ymin + j * dy * pymax = pymin + dy */ __pyx_t_14 = __pyx_v_ny; __pyx_t_15 = __pyx_t_14; for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) { __pyx_v_j = __pyx_t_16; /* "regions/_geometry/elliptical_overlap.pyx":109 * if pxmax > bxmin and pxmin < bxmax: * for j in range(ny): * pymin = ymin + j * dy # <<<<<<<<<<<<<< * pymax = pymin + dy * if pymax > bymin and pymin < bymax: */ __pyx_v_pymin = (__pyx_v_ymin + (__pyx_v_j * __pyx_v_dy)); /* "regions/_geometry/elliptical_overlap.pyx":110 * for j in range(ny): * pymin = ymin + j * dy * pymax = pymin + dy # <<<<<<<<<<<<<< * if pymax > bymin and pymin < bymax: * if use_exact: */ __pyx_v_pymax = (__pyx_v_pymin + __pyx_v_dy); /* "regions/_geometry/elliptical_overlap.pyx":111 * pymin = ymin + j * dy * pymax = pymin + dy * if pymax > bymin and pymin < bymax: # <<<<<<<<<<<<<< * if use_exact: * frac[j, i] = elliptical_overlap_single_exact( */ __pyx_t_13 = ((__pyx_v_pymax > __pyx_v_bymin) != 0); if (__pyx_t_13) { } else { __pyx_t_12 = __pyx_t_13; goto __pyx_L11_bool_binop_done; } __pyx_t_13 = ((__pyx_v_pymin < __pyx_v_bymax) != 0); __pyx_t_12 = __pyx_t_13; __pyx_L11_bool_binop_done:; if (__pyx_t_12) { /* "regions/_geometry/elliptical_overlap.pyx":112 * pymax = pymin + dy * if pymax > bymin and pymin < bymax: * if use_exact: # <<<<<<<<<<<<<< * frac[j, i] = elliptical_overlap_single_exact( * pxmin, pymin, pxmax, pymax, rx, ry, theta) * norm */ __pyx_t_12 = (__pyx_v_use_exact != 0); if (__pyx_t_12) { /* "regions/_geometry/elliptical_overlap.pyx":113 * if pymax > bymin and pymin < bymax: * if use_exact: * frac[j, i] = elliptical_overlap_single_exact( # <<<<<<<<<<<<<< * pxmin, pymin, pxmax, pymax, rx, ry, theta) * norm * else: */ __pyx_t_17 = __pyx_v_j; __pyx_t_18 = __pyx_v_i; __pyx_t_19 = -1; if (unlikely(__pyx_t_17 >= (size_t)__pyx_pybuffernd_frac.diminfo[0].shape)) __pyx_t_19 = 0; if (unlikely(__pyx_t_18 >= (size_t)__pyx_pybuffernd_frac.diminfo[1].shape)) __pyx_t_19 = 1; if (unlikely(__pyx_t_19 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_19); __PYX_ERR(0, 113, __pyx_L1_error) } *__Pyx_BufPtrStrided2d(__pyx_t_7regions_9_geometry_18elliptical_overlap_DTYPE_t *, __pyx_pybuffernd_frac.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_frac.diminfo[0].strides, __pyx_t_18, __pyx_pybuffernd_frac.diminfo[1].strides) = (__pyx_f_7regions_9_geometry_18elliptical_overlap_elliptical_overlap_single_exact(__pyx_v_pxmin, __pyx_v_pymin, __pyx_v_pxmax, __pyx_v_pymax, __pyx_v_rx, __pyx_v_ry, __pyx_v_theta) * __pyx_v_norm); /* "regions/_geometry/elliptical_overlap.pyx":112 * pymax = pymin + dy * if pymax > bymin and pymin < bymax: * if use_exact: # <<<<<<<<<<<<<< * frac[j, i] = elliptical_overlap_single_exact( * pxmin, pymin, pxmax, pymax, rx, ry, theta) * norm */ goto __pyx_L13; } /* "regions/_geometry/elliptical_overlap.pyx":116 * pxmin, pymin, pxmax, pymax, rx, ry, theta) * norm * else: * frac[j, i] = elliptical_overlap_single_subpixel( # <<<<<<<<<<<<<< * pxmin, pymin, pxmax, pymax, rx, ry, theta, * subpixels) */ /*else*/ { /* "regions/_geometry/elliptical_overlap.pyx":118 * frac[j, i] = elliptical_overlap_single_subpixel( * pxmin, pymin, pxmax, pymax, rx, ry, theta, * subpixels) # <<<<<<<<<<<<<< * return frac * */ __pyx_t_20 = __pyx_v_j; __pyx_t_21 = __pyx_v_i; __pyx_t_19 = -1; if (unlikely(__pyx_t_20 >= (size_t)__pyx_pybuffernd_frac.diminfo[0].shape)) __pyx_t_19 = 0; if (unlikely(__pyx_t_21 >= (size_t)__pyx_pybuffernd_frac.diminfo[1].shape)) __pyx_t_19 = 1; if (unlikely(__pyx_t_19 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_19); __PYX_ERR(0, 116, __pyx_L1_error) } *__Pyx_BufPtrStrided2d(__pyx_t_7regions_9_geometry_18elliptical_overlap_DTYPE_t *, __pyx_pybuffernd_frac.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_frac.diminfo[0].strides, __pyx_t_21, __pyx_pybuffernd_frac.diminfo[1].strides) = __pyx_f_7regions_9_geometry_18elliptical_overlap_elliptical_overlap_single_subpixel(__pyx_v_pxmin, __pyx_v_pymin, __pyx_v_pxmax, __pyx_v_pymax, __pyx_v_rx, __pyx_v_ry, __pyx_v_theta, __pyx_v_subpixels); } __pyx_L13:; /* "regions/_geometry/elliptical_overlap.pyx":111 * pymin = ymin + j * dy * pymax = pymin + dy * if pymax > bymin and pymin < bymax: # <<<<<<<<<<<<<< * if use_exact: * frac[j, i] = elliptical_overlap_single_exact( */ } } /* "regions/_geometry/elliptical_overlap.pyx":107 * pxmin = xmin + i * dx # lower end of pixel * pxmax = pxmin + dx # upper end of pixel * if pxmax > bxmin and pxmin < bxmax: # <<<<<<<<<<<<<< * for j in range(ny): * pymin = ymin + j * dy */ } } /* "regions/_geometry/elliptical_overlap.pyx":119 * pxmin, pymin, pxmax, pymax, rx, ry, theta, * subpixels) * return frac # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_frac)); __pyx_r = ((PyObject *)__pyx_v_frac); goto __pyx_L0; /* "regions/_geometry/elliptical_overlap.pyx":41 * * * def elliptical_overlap_grid(double xmin, double xmax, double ymin, double ymax, # <<<<<<<<<<<<<< * int nx, int ny, double rx, double ry, double theta, * int use_exact, int subpixels): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_frac.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("regions._geometry.elliptical_overlap.elliptical_overlap_grid", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_frac.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_frac); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/elliptical_overlap.pyx":128 * * * cdef double elliptical_overlap_single_subpixel(double x0, double y0, # <<<<<<<<<<<<<< * double x1, double y1, * double rx, double ry, */ static double __pyx_f_7regions_9_geometry_18elliptical_overlap_elliptical_overlap_single_subpixel(double __pyx_v_x0, double __pyx_v_y0, double __pyx_v_x1, double __pyx_v_y1, double __pyx_v_rx, double __pyx_v_ry, double __pyx_v_theta, int __pyx_v_subpixels) { CYTHON_UNUSED unsigned int __pyx_v_i; CYTHON_UNUSED unsigned int __pyx_v_j; double __pyx_v_x; double __pyx_v_y; double __pyx_v_frac; double __pyx_v_inv_rx_sq; double __pyx_v_inv_ry_sq; double __pyx_v_cos_theta; double __pyx_v_sin_theta; double __pyx_v_dx; double __pyx_v_dy; double __pyx_v_x_tr; double __pyx_v_y_tr; double __pyx_r; __Pyx_RefNannyDeclarations double __pyx_t_1; int __pyx_t_2; int __pyx_t_3; unsigned int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; unsigned int __pyx_t_7; int __pyx_t_8; __Pyx_RefNannySetupContext("elliptical_overlap_single_subpixel", 0); /* "regions/_geometry/elliptical_overlap.pyx":139 * cdef unsigned int i, j * cdef double x, y * cdef double frac = 0. # Accumulator. # <<<<<<<<<<<<<< * cdef double inv_rx_sq, inv_ry_sq * cdef double cos_theta = cos(theta) */ __pyx_v_frac = 0.; /* "regions/_geometry/elliptical_overlap.pyx":141 * cdef double frac = 0. # Accumulator. * cdef double inv_rx_sq, inv_ry_sq * cdef double cos_theta = cos(theta) # <<<<<<<<<<<<<< * cdef double sin_theta = sin(theta) * cdef double dx, dy */ __pyx_v_cos_theta = cos(__pyx_v_theta); /* "regions/_geometry/elliptical_overlap.pyx":142 * cdef double inv_rx_sq, inv_ry_sq * cdef double cos_theta = cos(theta) * cdef double sin_theta = sin(theta) # <<<<<<<<<<<<<< * cdef double dx, dy * cdef double x_tr, y_tr */ __pyx_v_sin_theta = sin(__pyx_v_theta); /* "regions/_geometry/elliptical_overlap.pyx":146 * cdef double x_tr, y_tr * * dx = (x1 - x0) / subpixels # <<<<<<<<<<<<<< * dy = (y1 - y0) / subpixels * */ __pyx_t_1 = (__pyx_v_x1 - __pyx_v_x0); if (unlikely(__pyx_v_subpixels == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 146, __pyx_L1_error) } __pyx_v_dx = (__pyx_t_1 / ((double)__pyx_v_subpixels)); /* "regions/_geometry/elliptical_overlap.pyx":147 * * dx = (x1 - x0) / subpixels * dy = (y1 - y0) / subpixels # <<<<<<<<<<<<<< * * inv_rx_sq = 1. / (rx * rx) */ __pyx_t_1 = (__pyx_v_y1 - __pyx_v_y0); if (unlikely(__pyx_v_subpixels == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 147, __pyx_L1_error) } __pyx_v_dy = (__pyx_t_1 / ((double)__pyx_v_subpixels)); /* "regions/_geometry/elliptical_overlap.pyx":149 * dy = (y1 - y0) / subpixels * * inv_rx_sq = 1. / (rx * rx) # <<<<<<<<<<<<<< * inv_ry_sq = 1. / (ry * ry) * */ __pyx_t_1 = (__pyx_v_rx * __pyx_v_rx); if (unlikely(__pyx_t_1 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 149, __pyx_L1_error) } __pyx_v_inv_rx_sq = (1. / __pyx_t_1); /* "regions/_geometry/elliptical_overlap.pyx":150 * * inv_rx_sq = 1. / (rx * rx) * inv_ry_sq = 1. / (ry * ry) # <<<<<<<<<<<<<< * * x = x0 - 0.5 * dx */ __pyx_t_1 = (__pyx_v_ry * __pyx_v_ry); if (unlikely(__pyx_t_1 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 150, __pyx_L1_error) } __pyx_v_inv_ry_sq = (1. / __pyx_t_1); /* "regions/_geometry/elliptical_overlap.pyx":152 * inv_ry_sq = 1. / (ry * ry) * * x = x0 - 0.5 * dx # <<<<<<<<<<<<<< * for i in range(subpixels): * x += dx */ __pyx_v_x = (__pyx_v_x0 - (0.5 * __pyx_v_dx)); /* "regions/_geometry/elliptical_overlap.pyx":153 * * x = x0 - 0.5 * dx * for i in range(subpixels): # <<<<<<<<<<<<<< * x += dx * y = y0 - 0.5 * dy */ __pyx_t_2 = __pyx_v_subpixels; __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; /* "regions/_geometry/elliptical_overlap.pyx":154 * x = x0 - 0.5 * dx * for i in range(subpixels): * x += dx # <<<<<<<<<<<<<< * y = y0 - 0.5 * dy * for j in range(subpixels): */ __pyx_v_x = (__pyx_v_x + __pyx_v_dx); /* "regions/_geometry/elliptical_overlap.pyx":155 * for i in range(subpixels): * x += dx * y = y0 - 0.5 * dy # <<<<<<<<<<<<<< * for j in range(subpixels): * y += dy */ __pyx_v_y = (__pyx_v_y0 - (0.5 * __pyx_v_dy)); /* "regions/_geometry/elliptical_overlap.pyx":156 * x += dx * y = y0 - 0.5 * dy * for j in range(subpixels): # <<<<<<<<<<<<<< * y += dy * */ __pyx_t_5 = __pyx_v_subpixels; __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_j = __pyx_t_7; /* "regions/_geometry/elliptical_overlap.pyx":157 * y = y0 - 0.5 * dy * for j in range(subpixels): * y += dy # <<<<<<<<<<<<<< * * # Transform into frame of rotated ellipse */ __pyx_v_y = (__pyx_v_y + __pyx_v_dy); /* "regions/_geometry/elliptical_overlap.pyx":160 * * # Transform into frame of rotated ellipse * x_tr = y * sin_theta + x * cos_theta # <<<<<<<<<<<<<< * y_tr = y * cos_theta - x * sin_theta * */ __pyx_v_x_tr = ((__pyx_v_y * __pyx_v_sin_theta) + (__pyx_v_x * __pyx_v_cos_theta)); /* "regions/_geometry/elliptical_overlap.pyx":161 * # Transform into frame of rotated ellipse * x_tr = y * sin_theta + x * cos_theta * y_tr = y * cos_theta - x * sin_theta # <<<<<<<<<<<<<< * * if x_tr * x_tr * inv_rx_sq + y_tr * y_tr * inv_ry_sq < 1.: */ __pyx_v_y_tr = ((__pyx_v_y * __pyx_v_cos_theta) - (__pyx_v_x * __pyx_v_sin_theta)); /* "regions/_geometry/elliptical_overlap.pyx":163 * y_tr = y * cos_theta - x * sin_theta * * if x_tr * x_tr * inv_rx_sq + y_tr * y_tr * inv_ry_sq < 1.: # <<<<<<<<<<<<<< * frac += 1. * */ __pyx_t_8 = (((((__pyx_v_x_tr * __pyx_v_x_tr) * __pyx_v_inv_rx_sq) + ((__pyx_v_y_tr * __pyx_v_y_tr) * __pyx_v_inv_ry_sq)) < 1.) != 0); if (__pyx_t_8) { /* "regions/_geometry/elliptical_overlap.pyx":164 * * if x_tr * x_tr * inv_rx_sq + y_tr * y_tr * inv_ry_sq < 1.: * frac += 1. # <<<<<<<<<<<<<< * * return frac / (subpixels * subpixels) */ __pyx_v_frac = (__pyx_v_frac + 1.); /* "regions/_geometry/elliptical_overlap.pyx":163 * y_tr = y * cos_theta - x * sin_theta * * if x_tr * x_tr * inv_rx_sq + y_tr * y_tr * inv_ry_sq < 1.: # <<<<<<<<<<<<<< * frac += 1. * */ } } } /* "regions/_geometry/elliptical_overlap.pyx":166 * frac += 1. * * return frac / (subpixels * subpixels) # <<<<<<<<<<<<<< * * */ __pyx_t_2 = (__pyx_v_subpixels * __pyx_v_subpixels); if (unlikely(__pyx_t_2 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 166, __pyx_L1_error) } __pyx_r = (__pyx_v_frac / ((double)__pyx_t_2)); goto __pyx_L0; /* "regions/_geometry/elliptical_overlap.pyx":128 * * * cdef double elliptical_overlap_single_subpixel(double x0, double y0, # <<<<<<<<<<<<<< * double x1, double y1, * double rx, double ry, */ /* function exit code */ __pyx_L1_error:; __Pyx_WriteUnraisable("regions._geometry.elliptical_overlap.elliptical_overlap_single_subpixel", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/elliptical_overlap.pyx":169 * * * cdef double elliptical_overlap_single_exact(double xmin, double ymin, # <<<<<<<<<<<<<< * double xmax, double ymax, * double rx, double ry, */ static double __pyx_f_7regions_9_geometry_18elliptical_overlap_elliptical_overlap_single_exact(double __pyx_v_xmin, double __pyx_v_ymin, double __pyx_v_xmax, double __pyx_v_ymax, double __pyx_v_rx, double __pyx_v_ry, double __pyx_v_theta) { double __pyx_v_cos_m_theta; double __pyx_v_sin_m_theta; double __pyx_v_scale; double __pyx_v_x1; double __pyx_v_y1; double __pyx_v_x2; double __pyx_v_y2; double __pyx_v_x3; double __pyx_v_y3; double __pyx_v_x4; double __pyx_v_y4; double __pyx_r; __Pyx_RefNannyDeclarations double __pyx_t_1; double __pyx_t_2; double __pyx_t_3; __Pyx_RefNannySetupContext("elliptical_overlap_single_exact", 0); /* "regions/_geometry/elliptical_overlap.pyx":179 * """ * * cdef double cos_m_theta = cos(-theta) # <<<<<<<<<<<<<< * cdef double sin_m_theta = sin(-theta) * cdef double scale */ __pyx_v_cos_m_theta = cos((-__pyx_v_theta)); /* "regions/_geometry/elliptical_overlap.pyx":180 * * cdef double cos_m_theta = cos(-theta) * cdef double sin_m_theta = sin(-theta) # <<<<<<<<<<<<<< * cdef double scale * */ __pyx_v_sin_m_theta = sin((-__pyx_v_theta)); /* "regions/_geometry/elliptical_overlap.pyx":184 * * # Find scale by which the areas will be shrunk * scale = rx * ry # <<<<<<<<<<<<<< * * # Reproject rectangle to frame of reference in which ellipse is a */ __pyx_v_scale = (__pyx_v_rx * __pyx_v_ry); /* "regions/_geometry/elliptical_overlap.pyx":188 * # Reproject rectangle to frame of reference in which ellipse is a * # unit circle * x1, y1 = ((xmin * cos_m_theta - ymin * sin_m_theta) / rx, # <<<<<<<<<<<<<< * (xmin * sin_m_theta + ymin * cos_m_theta) / ry) * x2, y2 = ((xmax * cos_m_theta - ymin * sin_m_theta) / rx, */ __pyx_t_1 = ((__pyx_v_xmin * __pyx_v_cos_m_theta) - (__pyx_v_ymin * __pyx_v_sin_m_theta)); if (unlikely(__pyx_v_rx == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 188, __pyx_L1_error) } __pyx_t_2 = (__pyx_t_1 / __pyx_v_rx); /* "regions/_geometry/elliptical_overlap.pyx":189 * # unit circle * x1, y1 = ((xmin * cos_m_theta - ymin * sin_m_theta) / rx, * (xmin * sin_m_theta + ymin * cos_m_theta) / ry) # <<<<<<<<<<<<<< * x2, y2 = ((xmax * cos_m_theta - ymin * sin_m_theta) / rx, * (xmax * sin_m_theta + ymin * cos_m_theta) / ry) */ __pyx_t_1 = ((__pyx_v_xmin * __pyx_v_sin_m_theta) + (__pyx_v_ymin * __pyx_v_cos_m_theta)); if (unlikely(__pyx_v_ry == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 189, __pyx_L1_error) } __pyx_t_3 = (__pyx_t_1 / __pyx_v_ry); __pyx_v_x1 = __pyx_t_2; __pyx_v_y1 = __pyx_t_3; /* "regions/_geometry/elliptical_overlap.pyx":190 * x1, y1 = ((xmin * cos_m_theta - ymin * sin_m_theta) / rx, * (xmin * sin_m_theta + ymin * cos_m_theta) / ry) * x2, y2 = ((xmax * cos_m_theta - ymin * sin_m_theta) / rx, # <<<<<<<<<<<<<< * (xmax * sin_m_theta + ymin * cos_m_theta) / ry) * x3, y3 = ((xmax * cos_m_theta - ymax * sin_m_theta) / rx, */ __pyx_t_3 = ((__pyx_v_xmax * __pyx_v_cos_m_theta) - (__pyx_v_ymin * __pyx_v_sin_m_theta)); if (unlikely(__pyx_v_rx == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 190, __pyx_L1_error) } __pyx_t_2 = (__pyx_t_3 / __pyx_v_rx); /* "regions/_geometry/elliptical_overlap.pyx":191 * (xmin * sin_m_theta + ymin * cos_m_theta) / ry) * x2, y2 = ((xmax * cos_m_theta - ymin * sin_m_theta) / rx, * (xmax * sin_m_theta + ymin * cos_m_theta) / ry) # <<<<<<<<<<<<<< * x3, y3 = ((xmax * cos_m_theta - ymax * sin_m_theta) / rx, * (xmax * sin_m_theta + ymax * cos_m_theta) / ry) */ __pyx_t_3 = ((__pyx_v_xmax * __pyx_v_sin_m_theta) + (__pyx_v_ymin * __pyx_v_cos_m_theta)); if (unlikely(__pyx_v_ry == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 191, __pyx_L1_error) } __pyx_t_1 = (__pyx_t_3 / __pyx_v_ry); __pyx_v_x2 = __pyx_t_2; __pyx_v_y2 = __pyx_t_1; /* "regions/_geometry/elliptical_overlap.pyx":192 * x2, y2 = ((xmax * cos_m_theta - ymin * sin_m_theta) / rx, * (xmax * sin_m_theta + ymin * cos_m_theta) / ry) * x3, y3 = ((xmax * cos_m_theta - ymax * sin_m_theta) / rx, # <<<<<<<<<<<<<< * (xmax * sin_m_theta + ymax * cos_m_theta) / ry) * x4, y4 = ((xmin * cos_m_theta - ymax * sin_m_theta) / rx, */ __pyx_t_1 = ((__pyx_v_xmax * __pyx_v_cos_m_theta) - (__pyx_v_ymax * __pyx_v_sin_m_theta)); if (unlikely(__pyx_v_rx == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 192, __pyx_L1_error) } __pyx_t_2 = (__pyx_t_1 / __pyx_v_rx); /* "regions/_geometry/elliptical_overlap.pyx":193 * (xmax * sin_m_theta + ymin * cos_m_theta) / ry) * x3, y3 = ((xmax * cos_m_theta - ymax * sin_m_theta) / rx, * (xmax * sin_m_theta + ymax * cos_m_theta) / ry) # <<<<<<<<<<<<<< * x4, y4 = ((xmin * cos_m_theta - ymax * sin_m_theta) / rx, * (xmin * sin_m_theta + ymax * cos_m_theta) / ry) */ __pyx_t_1 = ((__pyx_v_xmax * __pyx_v_sin_m_theta) + (__pyx_v_ymax * __pyx_v_cos_m_theta)); if (unlikely(__pyx_v_ry == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 193, __pyx_L1_error) } __pyx_t_3 = (__pyx_t_1 / __pyx_v_ry); __pyx_v_x3 = __pyx_t_2; __pyx_v_y3 = __pyx_t_3; /* "regions/_geometry/elliptical_overlap.pyx":194 * x3, y3 = ((xmax * cos_m_theta - ymax * sin_m_theta) / rx, * (xmax * sin_m_theta + ymax * cos_m_theta) / ry) * x4, y4 = ((xmin * cos_m_theta - ymax * sin_m_theta) / rx, # <<<<<<<<<<<<<< * (xmin * sin_m_theta + ymax * cos_m_theta) / ry) * */ __pyx_t_3 = ((__pyx_v_xmin * __pyx_v_cos_m_theta) - (__pyx_v_ymax * __pyx_v_sin_m_theta)); if (unlikely(__pyx_v_rx == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 194, __pyx_L1_error) } __pyx_t_2 = (__pyx_t_3 / __pyx_v_rx); /* "regions/_geometry/elliptical_overlap.pyx":195 * (xmax * sin_m_theta + ymax * cos_m_theta) / ry) * x4, y4 = ((xmin * cos_m_theta - ymax * sin_m_theta) / rx, * (xmin * sin_m_theta + ymax * cos_m_theta) / ry) # <<<<<<<<<<<<<< * * # Divide resulting quadrilateral into two triangles and find */ __pyx_t_3 = ((__pyx_v_xmin * __pyx_v_sin_m_theta) + (__pyx_v_ymax * __pyx_v_cos_m_theta)); if (unlikely(__pyx_v_ry == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 195, __pyx_L1_error) } __pyx_t_1 = (__pyx_t_3 / __pyx_v_ry); __pyx_v_x4 = __pyx_t_2; __pyx_v_y4 = __pyx_t_1; /* "regions/_geometry/elliptical_overlap.pyx":200 * # intersection with unit circle * return (overlap_area_triangle_unit_circle(x1, y1, x2, y2, x3, y3) + * overlap_area_triangle_unit_circle(x1, y1, x4, y4, x3, y3)) * scale # <<<<<<<<<<<<<< */ __pyx_r = ((__pyx_f_7regions_9_geometry_4core_overlap_area_triangle_unit_circle(__pyx_v_x1, __pyx_v_y1, __pyx_v_x2, __pyx_v_y2, __pyx_v_x3, __pyx_v_y3) + __pyx_f_7regions_9_geometry_4core_overlap_area_triangle_unit_circle(__pyx_v_x1, __pyx_v_y1, __pyx_v_x4, __pyx_v_y4, __pyx_v_x3, __pyx_v_y3)) * __pyx_v_scale); goto __pyx_L0; /* "regions/_geometry/elliptical_overlap.pyx":169 * * * cdef double elliptical_overlap_single_exact(double xmin, double ymin, # <<<<<<<<<<<<<< * double xmax, double ymax, * double rx, double ry, */ /* function exit code */ __pyx_L1_error:; __Pyx_WriteUnraisable("regions._geometry.elliptical_overlap.elliptical_overlap_single_exact", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< * # This implementation of getbuffer is geared towards Cython * # requirements, and does not yet fulfill the PEP. */ /* Python wrapper */ static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_v_i; int __pyx_v_ndim; int __pyx_v_endian_detector; int __pyx_v_little_endian; int __pyx_v_t; char *__pyx_v_f; PyArray_Descr *__pyx_v_descr = 0; int __pyx_v_offset; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyArray_Descr *__pyx_t_7; PyObject *__pyx_t_8 = NULL; char *__pyx_t_9; if (__pyx_v_info == NULL) { PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); return -1; } __Pyx_RefNannySetupContext("__getbuffer__", 0); __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 * * cdef int i, ndim * cdef int endian_detector = 1 # <<<<<<<<<<<<<< * cdef bint little_endian = ((&endian_detector)[0] != 0) * */ __pyx_v_endian_detector = 1; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 * cdef int i, ndim * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * * ndim = PyArray_NDIM(self) */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 * cdef bint little_endian = ((&endian_detector)[0] != 0) * * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) */ __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< * raise ValueError(u"ndarray is not C contiguous") * */ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 272, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L7_bool_binop_done; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< * raise ValueError(u"ndarray is not Fortran contiguous") * */ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L7_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 276, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 * raise ValueError(u"ndarray is not Fortran contiguous") * * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 * * info.buf = PyArray_DATA(self) * info.ndim = ndim # <<<<<<<<<<<<<< * if sizeof(npy_intp) != sizeof(Py_ssize_t): * # Allocate new buffer for strides and shape info. */ __pyx_v_info->ndim = __pyx_v_ndim; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. */ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< * info.shape = info.strides + ndim * for i in range(ndim): */ __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim # <<<<<<<<<<<<<< * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] */ __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim * for i in range(ndim): # <<<<<<<<<<<<<< * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] */ __pyx_t_4 = __pyx_v_ndim; __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286 * info.shape = info.strides + ndim * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< * info.shape[i] = PyArray_DIMS(self)[i] * else: */ (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287 * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< * else: * info.strides = PyArray_STRIDES(self) */ (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. */ goto __pyx_L9; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289 * info.shape[i] = PyArray_DIMS(self)[i] * else: * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL */ /*else*/ { __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 * else: * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) */ __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); } __pyx_L9:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL # <<<<<<<<<<<<<< * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) */ __pyx_v_info->suboffsets = NULL; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< * info.readonly = not PyArray_ISWRITEABLE(self) * */ __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< * * cdef int t */ __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296 * * cdef int t * cdef char* f = NULL # <<<<<<<<<<<<<< * cdef dtype descr = PyArray_DESCR(self) * cdef int offset */ __pyx_v_f = NULL; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297 * cdef int t * cdef char* f = NULL * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< * cdef int offset * */ __pyx_t_7 = PyArray_DESCR(__pyx_v_self); __pyx_t_3 = ((PyObject *)__pyx_t_7); __Pyx_INCREF(__pyx_t_3); __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300 * cdef int offset * * info.obj = self # <<<<<<<<<<<<<< * * if not PyDataType_HASFIELDS(descr): */ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or */ __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303 * * if not PyDataType_HASFIELDS(descr): * t = descr.type_num # <<<<<<<<<<<<<< * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): */ __pyx_t_4 = __pyx_v_descr->type_num; __pyx_v_t = __pyx_t_4; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); if (!__pyx_t_2) { goto __pyx_L15_next_or; } else { } __pyx_t_2 = (__pyx_v_little_endian != 0); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L14_bool_binop_done; } __pyx_L15_next_or:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305 * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" */ __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L14_bool_binop_done; } __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L14_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 306, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307 * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" */ switch (__pyx_v_t) { case NPY_BYTE: __pyx_v_f = ((char *)"b"); break; case NPY_UBYTE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308 * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" */ __pyx_v_f = ((char *)"B"); break; case NPY_SHORT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309 * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" */ __pyx_v_f = ((char *)"h"); break; case NPY_USHORT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310 * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" */ __pyx_v_f = ((char *)"H"); break; case NPY_INT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311 * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" */ __pyx_v_f = ((char *)"i"); break; case NPY_UINT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312 * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" */ __pyx_v_f = ((char *)"I"); break; case NPY_LONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313 * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" */ __pyx_v_f = ((char *)"l"); break; case NPY_ULONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314 * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" */ __pyx_v_f = ((char *)"L"); break; case NPY_LONGLONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315 * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" */ __pyx_v_f = ((char *)"q"); break; case NPY_ULONGLONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316 * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" */ __pyx_v_f = ((char *)"Q"); break; case NPY_FLOAT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317 * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" */ __pyx_v_f = ((char *)"f"); break; case NPY_DOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318 * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" */ __pyx_v_f = ((char *)"d"); break; case NPY_LONGDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319 * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" */ __pyx_v_f = ((char *)"g"); break; case NPY_CFLOAT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320 * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" */ __pyx_v_f = ((char *)"Zf"); break; case NPY_CDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321 * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" */ __pyx_v_f = ((char *)"Zd"); break; case NPY_CLONGDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322 * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f = "O" * else: */ __pyx_v_f = ((char *)"Zg"); break; case NPY_OBJECT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323 * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ __pyx_v_f = ((char *)"O"); break; default: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325 * elif t == NPY_OBJECT: f = "O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * info.format = f * return */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 325, __pyx_L1_error) break; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f # <<<<<<<<<<<<<< * return * else: */ __pyx_v_info->format = __pyx_v_f; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327 * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f * return # <<<<<<<<<<<<<< * else: * info.format = PyObject_Malloc(_buffer_format_string_len) */ __pyx_r = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329 * return * else: * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 */ /*else*/ { __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330 * else: * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< * offset = 0 * f = _util_dtypestring(descr, info.format + 1, */ (__pyx_v_info->format[0]) = '^'; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331 * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 # <<<<<<<<<<<<<< * f = _util_dtypestring(descr, info.format + 1, * info.format + _buffer_format_string_len, */ __pyx_v_offset = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332 * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< * info.format + _buffer_format_string_len, * &offset) */ __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error) __pyx_v_f = __pyx_t_9; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335 * info.format + _buffer_format_string_len, * &offset) * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< * * def __releasebuffer__(ndarray self, Py_buffer* info): */ (__pyx_v_f[0]) = '\x00'; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< * # This implementation of getbuffer is geared towards Cython * # requirements, and does not yet fulfill the PEP. */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; if (__pyx_v_info->obj != NULL) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } goto __pyx_L2; __pyx_L0:; if (__pyx_v_info->obj == Py_None) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_descr); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) */ /* Python wrapper */ static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__releasebuffer__", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339 * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) # <<<<<<<<<<<<<< * if sizeof(npy_intp) != sizeof(Py_ssize_t): * PyObject_Free(info.strides) */ PyObject_Free(__pyx_v_info->format); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * PyObject_Free(info.strides) * # info.shape was stored after info.strides in the same block */ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341 * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): * PyObject_Free(info.strides) # <<<<<<<<<<<<<< * # info.shape was stored after info.strides in the same block * */ PyObject_Free(__pyx_v_info->strides); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * PyObject_Free(info.strides) * # info.shape was stored after info.strides in the same block */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":825 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 828, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 831, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * * cdef inline tuple PyDataType_SHAPE(dtype d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< * else: * return () */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_empty_tuple); __pyx_r = __pyx_empty_tuple; goto __pyx_L0; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< * # Recursive utility function used in __getbuffer__ to get format * # string. The new location in the format string is returned. */ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { PyArray_Descr *__pyx_v_child = 0; int __pyx_v_endian_detector; int __pyx_v_little_endian; PyObject *__pyx_v_fields = 0; PyObject *__pyx_v_childname = NULL; PyObject *__pyx_v_new_offset = NULL; PyObject *__pyx_v_t = NULL; char *__pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; int __pyx_t_7; long __pyx_t_8; char *__pyx_t_9; __Pyx_RefNannySetupContext("_util_dtypestring", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847 * * cdef dtype child * cdef int endian_detector = 1 # <<<<<<<<<<<<<< * cdef bint little_endian = ((&endian_detector)[0] != 0) * cdef tuple fields */ __pyx_v_endian_detector = 1; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":848 * cdef dtype child * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * cdef tuple fields * */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< * fields = descr.fields[childname] * child, new_offset = fields */ if (unlikely(__pyx_v_descr->names == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(1, 851, __pyx_L1_error) } __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 851, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852 * * for childname in descr.names: * fields = descr.fields[childname] # <<<<<<<<<<<<<< * child, new_offset = fields * */ if (unlikely(__pyx_v_descr->fields == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 852, __pyx_L1_error) } __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":853 * for childname in descr.names: * fields = descr.fields[childname] * child, new_offset = fields # <<<<<<<<<<<<<< * * if (end - f) - (new_offset - offset[0]) < 15: */ if (likely(__pyx_v_fields != Py_None)) { PyObject* sequence = __pyx_v_fields; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(1, 853, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } else { __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 853, __pyx_L1_error) } if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); __pyx_t_4 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 856, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); if (!__pyx_t_7) { goto __pyx_L8_next_or; } else { } __pyx_t_7 = (__pyx_v_little_endian != 0); if (!__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_L8_next_or:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859 * * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< * raise ValueError(u"Non-native byte order not supported") * # One could encode it in the format string and have Cython */ __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); if (__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_6 = __pyx_t_7; __pyx_L7_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":860 * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * # One could encode it in the format string and have Cython * # complain instead, BUT: < and > in format strings also imply */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 860, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 860, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870 * * # Output padding bytes * while offset[0] < new_offset: # <<<<<<<<<<<<<< * f[0] = 120 # "x"; pad byte * f += 1 */ while (1) { __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_6) break; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871 * # Output padding bytes * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< * f += 1 * offset[0] += 1 */ (__pyx_v_f[0]) = 0x78; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872 * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte * f += 1 # <<<<<<<<<<<<<< * offset[0] += 1 * */ __pyx_v_f = (__pyx_v_f + 1); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":873 * f[0] = 120 # "x"; pad byte * f += 1 * offset[0] += 1 # <<<<<<<<<<<<<< * * offset[0] += child.itemsize */ __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":875 * offset[0] += 1 * * offset[0] += child.itemsize # <<<<<<<<<<<<<< * * if not PyDataType_HASFIELDS(child): */ __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< * t = child.type_num * if end - f < 5: */ __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); if (__pyx_t_6) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 * * if not PyDataType_HASFIELDS(child): * t = child.type_num # <<<<<<<<<<<<<< * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); __pyx_t_4 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short.") * */ __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 880, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short.") * */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883 * * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 98; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884 * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 66; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885 * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x68; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886 * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 72; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887 * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x69; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888 * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 73; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889 * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x6C; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890 * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 76; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891 * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x71; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892 * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 81; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893 * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x66; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894 * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x64; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895 * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x67; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896 * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x66; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897 * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x64; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898 * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x67; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":899 * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(__pyx_t_6)) { (__pyx_v_f[0]) = 79; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901 * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * f += 1 * else: */ /*else*/ { __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 901, __pyx_L1_error) } __pyx_L15:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":902 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * f += 1 # <<<<<<<<<<<<<< * else: * # Cython ignores struct boundary information ("T{...}"), */ __pyx_v_f = (__pyx_v_f + 1); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< * t = child.type_num * if end - f < 5: */ goto __pyx_L13; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906 * # Cython ignores struct boundary information ("T{...}"), * # so don't output it * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< * return f * */ /*else*/ { __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 906, __pyx_L1_error) __pyx_v_f = __pyx_t_9; } __pyx_L13:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< * fields = descr.fields[childname] * child, new_offset = fields */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":907 * # so don't output it * f = _util_dtypestring(child, f, end, offset) * return f # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_f; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< * # Recursive utility function used in __getbuffer__ to get format * # string. The new location in the format string is returned. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_child); __Pyx_XDECREF(__pyx_v_fields); __Pyx_XDECREF(__pyx_v_childname); __Pyx_XDECREF(__pyx_v_new_offset); __Pyx_XDECREF(__pyx_v_t); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< * PyArray_SetBaseObject(arr, base) * */ Py_INCREF(__pyx_v_base); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1024 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * * cdef inline object get_array_base(ndarray arr): */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< * if base is NULL: * return None */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< * return base * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1030 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< * * # Versions of the import_* functions which are more suitable for */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * _import_array() */ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_array", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036 * cdef inline int import_array() except -1: * try: * _import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1036, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 * try: * _import_array() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.multiarray failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1037, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1038, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1038, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * _import_array() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_umath", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1042, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1043, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1044, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1044, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_ufunc", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1048, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1049, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1050 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1050, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1050, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec_elliptical_overlap(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_elliptical_overlap}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "elliptical_overlap", __pyx_k_The_functions_defined_here_allo, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_DTYPE, __pyx_k_DTYPE, sizeof(__pyx_k_DTYPE), 0, 0, 1, 1}, {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, {&__pyx_n_s_bxmax, __pyx_k_bxmax, sizeof(__pyx_k_bxmax), 0, 0, 1, 1}, {&__pyx_n_s_bxmin, __pyx_k_bxmin, sizeof(__pyx_k_bxmin), 0, 0, 1, 1}, {&__pyx_n_s_bymax, __pyx_k_bymax, sizeof(__pyx_k_bymax), 0, 0, 1, 1}, {&__pyx_n_s_bymin, __pyx_k_bymin, sizeof(__pyx_k_bymin), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, {&__pyx_n_s_dx, __pyx_k_dx, sizeof(__pyx_k_dx), 0, 0, 1, 1}, {&__pyx_n_s_dy, __pyx_k_dy, sizeof(__pyx_k_dy), 0, 0, 1, 1}, {&__pyx_n_s_elliptical_overlap_grid, __pyx_k_elliptical_overlap_grid, sizeof(__pyx_k_elliptical_overlap_grid), 0, 0, 1, 1}, {&__pyx_n_u_elliptical_overlap_grid, __pyx_k_elliptical_overlap_grid, sizeof(__pyx_k_elliptical_overlap_grid), 0, 1, 0, 1}, {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1}, {&__pyx_n_s_frac, __pyx_k_frac, sizeof(__pyx_k_frac), 0, 0, 1, 1}, {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, {&__pyx_n_s_norm, __pyx_k_norm, sizeof(__pyx_k_norm), 0, 0, 1, 1}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, {&__pyx_n_s_nx, __pyx_k_nx, sizeof(__pyx_k_nx), 0, 0, 1, 1}, {&__pyx_n_s_ny, __pyx_k_ny, sizeof(__pyx_k_ny), 0, 0, 1, 1}, {&__pyx_n_s_pxmax, __pyx_k_pxmax, sizeof(__pyx_k_pxmax), 0, 0, 1, 1}, {&__pyx_n_s_pxmin, __pyx_k_pxmin, sizeof(__pyx_k_pxmin), 0, 0, 1, 1}, {&__pyx_n_s_pymax, __pyx_k_pymax, sizeof(__pyx_k_pymax), 0, 0, 1, 1}, {&__pyx_n_s_pymin, __pyx_k_pymin, sizeof(__pyx_k_pymin), 0, 0, 1, 1}, {&__pyx_n_s_r, __pyx_k_r, sizeof(__pyx_k_r), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_kp_s_regions__geometry_elliptical_ove, __pyx_k_regions__geometry_elliptical_ove, sizeof(__pyx_k_regions__geometry_elliptical_ove), 0, 0, 1, 0}, {&__pyx_n_s_regions__geometry_elliptical_ove_2, __pyx_k_regions__geometry_elliptical_ove_2, sizeof(__pyx_k_regions__geometry_elliptical_ove_2), 0, 0, 1, 1}, {&__pyx_n_s_rx, __pyx_k_rx, sizeof(__pyx_k_rx), 0, 0, 1, 1}, {&__pyx_n_s_ry, __pyx_k_ry, sizeof(__pyx_k_ry), 0, 0, 1, 1}, {&__pyx_n_s_subpixels, __pyx_k_subpixels, sizeof(__pyx_k_subpixels), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_theta, __pyx_k_theta, sizeof(__pyx_k_theta), 0, 0, 1, 1}, {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, {&__pyx_n_s_use_exact, __pyx_k_use_exact, sizeof(__pyx_k_use_exact), 0, 0, 1, 1}, {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, {&__pyx_n_s_xmax, __pyx_k_xmax, sizeof(__pyx_k_xmax), 0, 0, 1, 1}, {&__pyx_n_s_xmin, __pyx_k_xmin, sizeof(__pyx_k_xmin), 0, 0, 1, 1}, {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, {&__pyx_n_s_ymax, __pyx_k_ymax, sizeof(__pyx_k_ymax), 0, 0, 1, 1}, {&__pyx_n_s_ymin, __pyx_k_ymin, sizeof(__pyx_k_ymin), 0, 0, 1, 1}, {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 104, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error) __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 856, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1038, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 1038, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 1044, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "regions/_geometry/elliptical_overlap.pyx":41 * * * def elliptical_overlap_grid(double xmin, double xmax, double ymin, double ymax, # <<<<<<<<<<<<<< * int nx, int ny, double rx, double ry, double theta, * int use_exact, int subpixels): */ __pyx_tuple__8 = PyTuple_Pack(28, __pyx_n_s_xmin, __pyx_n_s_xmax, __pyx_n_s_ymin, __pyx_n_s_ymax, __pyx_n_s_nx, __pyx_n_s_ny, __pyx_n_s_rx, __pyx_n_s_ry, __pyx_n_s_theta, __pyx_n_s_use_exact, __pyx_n_s_subpixels, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_dx, __pyx_n_s_dy, __pyx_n_s_bxmin, __pyx_n_s_bxmax, __pyx_n_s_bymin, __pyx_n_s_bymax, __pyx_n_s_pxmin, __pyx_n_s_pxmax, __pyx_n_s_pymin, __pyx_n_s_pymax, __pyx_n_s_norm, __pyx_n_s_frac, __pyx_n_s_r); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(11, 0, 28, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_regions__geometry_elliptical_ove, __pyx_n_s_elliptical_overlap_grid, 41, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 sizeof(PyTypeObject), #else sizeof(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(3, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(4, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error) __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error) __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 918, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __pyx_t_1 = PyImport_ImportModule("regions._geometry.core"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ImportFunction(__pyx_t_1, "distance", (void (**)(void))&__pyx_f_7regions_9_geometry_4core_distance, "double (double, double, double, double)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ImportFunction(__pyx_t_1, "area_triangle", (void (**)(void))&__pyx_f_7regions_9_geometry_4core_area_triangle, "double (double, double, double, double, double, double)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ImportFunction(__pyx_t_1, "overlap_area_triangle_unit_circle", (void (**)(void))&__pyx_f_7regions_9_geometry_4core_overlap_area_triangle_unit_circle, "double (double, double, double, double, double, double)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) Py_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } #if PY_MAJOR_VERSION < 3 #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC void #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #else #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyObject * #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC initelliptical_overlap(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC initelliptical_overlap(void) #else __Pyx_PyMODINIT_FUNC PyInit_elliptical_overlap(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_elliptical_overlap(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec_elliptical_overlap(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module 'elliptical_overlap' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_elliptical_overlap(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("elliptical_overlap", __pyx_methods, __pyx_k_The_functions_defined_here_allo, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_regions___geometry__elliptical_overlap) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "regions._geometry.elliptical_overlap")) { if (unlikely(PyDict_SetItemString(modules, "regions._geometry.elliptical_overlap", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); (void)__Pyx_modinit_type_init_code(); if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error; (void)__Pyx_modinit_variable_import_code(); if (unlikely(__Pyx_modinit_function_import_code() != 0)) goto __pyx_L1_error; /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "regions/_geometry/elliptical_overlap.pyx":14 * unicode_literals) * * import numpy as np # <<<<<<<<<<<<<< * cimport numpy as np * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/elliptical_overlap.pyx":18 * * * __all__ = ['elliptical_overlap_grid'] # <<<<<<<<<<<<<< * * */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_u_elliptical_overlap_grid); __Pyx_GIVEREF(__pyx_n_u_elliptical_overlap_grid); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_u_elliptical_overlap_grid); if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_t_1) < 0) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/elliptical_overlap.pyx":30 * from cpython cimport bool * * DTYPE = np.float64 # <<<<<<<<<<<<<< * ctypedef np.float64_t DTYPE_t * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE, __pyx_t_2) < 0) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/elliptical_overlap.pyx":41 * * * def elliptical_overlap_grid(double xmin, double xmax, double ymin, double ymax, # <<<<<<<<<<<<<< * int nx, int ny, double rx, double ry, double theta, * int use_exact, int subpixels): */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7regions_9_geometry_18elliptical_overlap_1elliptical_overlap_grid, NULL, __pyx_n_s_regions__geometry_elliptical_ove_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_elliptical_overlap_grid, __pyx_t_2) < 0) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/elliptical_overlap.pyx":1 * # Licensed under a 3-clause BSD style license - see LICENSE.rst # <<<<<<<<<<<<<< * # cython: language_level=3 * """ */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init regions._geometry.elliptical_overlap", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init regions._geometry.elliptical_overlap"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* IsLittleEndian */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) { union { uint32_t u32; uint8_t u8[4]; } S; S.u32 = 0x01020304; return S.u8[0] == 4; } /* BufferFormatCheck */ static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type) { stack[0].field = &ctx->root; stack[0].parent_offset = 0; ctx->root.type = type; ctx->root.name = "buffer dtype"; ctx->root.offset = 0; ctx->head = stack; ctx->head->field = &ctx->root; ctx->fmt_offset = 0; ctx->head->parent_offset = 0; ctx->new_packmode = '@'; ctx->enc_packmode = '@'; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->is_complex = 0; ctx->is_valid_array = 0; ctx->struct_alignment = 0; while (type->typegroup == 'S') { ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = 0; type = type->fields->type; } } static int __Pyx_BufFmt_ParseNumber(const char** ts) { int count; const char* t = *ts; if (*t < '0' || *t > '9') { return -1; } else { count = *t++ - '0'; while (*t >= '0' && *t <= '9') { count *= 10; count += *t++ - '0'; } } *ts = t; return count; } static int __Pyx_BufFmt_ExpectNumber(const char **ts) { int number = __Pyx_BufFmt_ParseNumber(ts); if (number == -1) PyErr_Format(PyExc_ValueError,\ "Does not understand character buffer dtype format string ('%c')", **ts); return number; } static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { PyErr_Format(PyExc_ValueError, "Unexpected format string character: '%c'", ch); } static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { switch (ch) { case 'c': return "'char'"; case 'b': return "'signed char'"; case 'B': return "'unsigned char'"; case 'h': return "'short'"; case 'H': return "'unsigned short'"; case 'i': return "'int'"; case 'I': return "'unsigned int'"; case 'l': return "'long'"; case 'L': return "'unsigned long'"; case 'q': return "'long long'"; case 'Q': return "'unsigned long long'"; case 'f': return (is_complex ? "'complex float'" : "'float'"); case 'd': return (is_complex ? "'complex double'" : "'double'"); case 'g': return (is_complex ? "'complex long double'" : "'long double'"); case 'T': return "a struct"; case 'O': return "Python object"; case 'P': return "a pointer"; case 's': case 'p': return "a string"; case 0: return "end"; default: return "unparseable format string"; } } static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return 2; case 'i': case 'I': case 'l': case 'L': return 4; case 'q': case 'Q': return 8; case 'f': return (is_complex ? 8 : 4); case 'd': return (is_complex ? 16 : 8); case 'g': { PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); return 0; } case 'O': case 'P': return sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { switch (ch) { case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(short); case 'i': case 'I': return sizeof(int); case 'l': case 'L': return sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(float) * (is_complex ? 2 : 1); case 'd': return sizeof(double) * (is_complex ? 2 : 1); case 'g': return sizeof(long double) * (is_complex ? 2 : 1); case 'O': case 'P': return sizeof(void*); default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } typedef struct { char c; short x; } __Pyx_st_short; typedef struct { char c; int x; } __Pyx_st_int; typedef struct { char c; long x; } __Pyx_st_long; typedef struct { char c; float x; } __Pyx_st_float; typedef struct { char c; double x; } __Pyx_st_double; typedef struct { char c; long double x; } __Pyx_st_longdouble; typedef struct { char c; void *x; } __Pyx_st_void_p; #ifdef HAVE_LONG_LONG typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_st_float) - sizeof(float); case 'd': return sizeof(__Pyx_st_double) - sizeof(double); case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } /* These are for computing the padding at the end of the struct to align on the first member of the struct. This will probably the same as above, but we don't have any guarantees. */ typedef struct { short x; char c; } __Pyx_pad_short; typedef struct { int x; char c; } __Pyx_pad_int; typedef struct { long x; char c; } __Pyx_pad_long; typedef struct { float x; char c; } __Pyx_pad_float; typedef struct { double x; char c; } __Pyx_pad_double; typedef struct { long double x; char c; } __Pyx_pad_longdouble; typedef struct { void *x; char c; } __Pyx_pad_void_p; #ifdef HAVE_LONG_LONG typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { switch (ch) { case 'c': return 'H'; case 'b': case 'h': case 'i': case 'l': case 'q': case 's': case 'p': return 'I'; case 'B': case 'H': case 'I': case 'L': case 'Q': return 'U'; case 'f': case 'd': case 'g': return (is_complex ? 'C' : 'R'); case 'O': return 'O'; case 'P': return 'P'; default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { if (ctx->head == NULL || ctx->head->field == &ctx->root) { const char* expected; const char* quote; if (ctx->head == NULL) { expected = "end"; quote = ""; } else { expected = ctx->head->field->type->name; quote = "'"; } PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected %s%s%s but got %s", quote, expected, quote, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); } else { __Pyx_StructField* field = ctx->head->field; __Pyx_StructField* parent = (ctx->head - 1)->field; PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), parent->type->name, field->name); } } static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { char group; size_t size, offset, arraysize = 1; if (ctx->enc_type == 0) return 0; if (ctx->head->field->type->arraysize[0]) { int i, ndim = 0; if (ctx->enc_type == 's' || ctx->enc_type == 'p') { ctx->is_valid_array = ctx->head->field->type->ndim == 1; ndim = 1; if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %zu", ctx->head->field->type->arraysize[0], ctx->enc_count); return -1; } } if (!ctx->is_valid_array) { PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", ctx->head->field->type->ndim, ndim); return -1; } for (i = 0; i < ctx->head->field->type->ndim; i++) { arraysize *= ctx->head->field->type->arraysize[i]; } ctx->is_valid_array = 0; ctx->enc_count = 1; } group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); do { __Pyx_StructField* field = ctx->head->field; __Pyx_TypeInfo* type = field->type; if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); } else { size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); } if (ctx->enc_packmode == '@') { size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); size_t align_mod_offset; if (align_at == 0) return -1; align_mod_offset = ctx->fmt_offset % align_at; if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; if (ctx->struct_alignment == 0) ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, ctx->is_complex); } if (type->size != size || type->typegroup != group) { if (type->typegroup == 'C' && type->fields != NULL) { size_t parent_offset = ctx->head->parent_offset + field->offset; ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = parent_offset; continue; } if ((type->typegroup == 'H' || group == 'H') && type->size == size) { } else { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } } offset = ctx->head->parent_offset + field->offset; if (ctx->fmt_offset != offset) { PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); return -1; } ctx->fmt_offset += size; if (arraysize) ctx->fmt_offset += (arraysize - 1) * size; --ctx->enc_count; while (1) { if (field == &ctx->root) { ctx->head = NULL; if (ctx->enc_count != 0) { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } break; } ctx->head->field = ++field; if (field->type == NULL) { --ctx->head; field = ctx->head->field; continue; } else if (field->type->typegroup == 'S') { size_t parent_offset = ctx->head->parent_offset + field->offset; if (field->type->fields->type == NULL) continue; field = field->type->fields; ++ctx->head; ctx->head->field = field; ctx->head->parent_offset = parent_offset; break; } else { break; } } } while (ctx->enc_count); ctx->enc_type = 0; ctx->is_complex = 0; return 0; } static PyObject * __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { const char *ts = *tsp; int i = 0, number; int ndim = ctx->head->field->type->ndim; ; ++ts; if (ctx->new_count != 1) { PyErr_SetString(PyExc_ValueError, "Cannot handle repeated arrays in format string"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; while (*ts && *ts != ')') { switch (*ts) { case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; default: break; } number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) return PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %d", ctx->head->field->type->arraysize[i], number); if (*ts != ',' && *ts != ')') return PyErr_Format(PyExc_ValueError, "Expected a comma in format string, got '%c'", *ts); if (*ts == ',') ts++; i++; } if (i != ndim) return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", ctx->head->field->type->ndim, i); if (!*ts) { PyErr_SetString(PyExc_ValueError, "Unexpected end of format string, expected ')'"); return NULL; } ctx->is_valid_array = 1; ctx->new_count = 1; *tsp = ++ts; return Py_None; } static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { int got_Z = 0; while (1) { switch(*ts) { case 0: if (ctx->enc_type != 0 && ctx->head == NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; if (ctx->head != NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } return ts; case ' ': case '\r': case '\n': ++ts; break; case '<': if (!__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '>': case '!': if (__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '=': case '@': case '^': ctx->new_packmode = *ts++; break; case 'T': { const char* ts_after_sub; size_t i, struct_count = ctx->new_count; size_t struct_alignment = ctx->struct_alignment; ctx->new_count = 1; ++ts; if (*ts != '{') { PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; ctx->enc_count = 0; ctx->struct_alignment = 0; ++ts; ts_after_sub = ts; for (i = 0; i != struct_count; ++i) { ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); if (!ts_after_sub) return NULL; } ts = ts_after_sub; if (struct_alignment) ctx->struct_alignment = struct_alignment; } break; case '}': { size_t alignment = ctx->struct_alignment; ++ts; if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; if (alignment && ctx->fmt_offset % alignment) { ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); } } return ts; case 'x': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->fmt_offset += ctx->new_count; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->enc_packmode = ctx->new_packmode; ++ts; break; case 'Z': got_Z = 1; ++ts; if (*ts != 'f' && *ts != 'd' && *ts != 'g') { __Pyx_BufFmt_RaiseUnexpectedChar('Z'); return NULL; } CYTHON_FALLTHROUGH; case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': case 'l': case 'L': case 'q': case 'Q': case 'f': case 'd': case 'g': case 'O': case 'p': if (ctx->enc_type == *ts && got_Z == ctx->is_complex && ctx->enc_packmode == ctx->new_packmode) { ctx->enc_count += ctx->new_count; ctx->new_count = 1; got_Z = 0; ++ts; break; } CYTHON_FALLTHROUGH; case 's': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_count = ctx->new_count; ctx->enc_packmode = ctx->new_packmode; ctx->enc_type = *ts; ctx->is_complex = got_Z; ++ts; ctx->new_count = 1; got_Z = 0; break; case ':': ++ts; while(*ts != ':') ++ts; ++ts; break; case '(': if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; break; default: { int number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; ctx->new_count = (size_t)number; } } } } /* BufferGetAndValidate */ static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { if (unlikely(info->buf == NULL)) return; if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; __Pyx_ReleaseBuffer(info); } static void __Pyx_ZeroBuffer(Py_buffer* buf) { buf->buf = NULL; buf->obj = NULL; buf->strides = __Pyx_zeros; buf->shape = __Pyx_zeros; buf->suboffsets = __Pyx_minusones; } static int __Pyx__GetBufferAndValidate( Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack) { buf->buf = NULL; if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { __Pyx_ZeroBuffer(buf); return -1; } if (unlikely(buf->ndim != nd)) { PyErr_Format(PyExc_ValueError, "Buffer has wrong number of dimensions (expected %d, got %d)", nd, buf->ndim); goto fail; } if (!cast) { __Pyx_BufFmt_Context ctx; __Pyx_BufFmt_Init(&ctx, stack, dtype); if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; } if (unlikely((size_t)buf->itemsize != dtype->size)) { PyErr_Format(PyExc_ValueError, "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", buf->itemsize, (buf->itemsize > 1) ? "s" : "", dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); goto fail; } if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; return 0; fail:; __Pyx_SafeReleaseBuffer(buf); return -1; } /* BufferIndexError */ static void __Pyx_RaiseBufferIndexError(int axis) { PyErr_Format(PyExc_IndexError, "Out of bounds on buffer access (axis %d)", axis); } /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* WriteUnraisableException */ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback, CYTHON_UNUSED int nogil) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_PyThreadState_declare #ifdef WITH_THREAD PyGILState_STATE state; if (nogil) state = PyGILState_Ensure(); #ifdef _MSC_VER else state = (PyGILState_STATE)-1; #endif #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } #ifdef WITH_THREAD if (nogil) PyGILState_Release(state); #endif } /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* DictGetItem */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); if (unlikely(!value)) { if (!PyErr_Occurred()) { if (unlikely(PyTuple_Check(key))) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) { PyErr_SetObject(PyExc_KeyError, args); Py_DECREF(args); } } else { PyErr_SetObject(PyExc_KeyError, key); } } return NULL; } Py_INCREF(value); return value; } #endif /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* RaiseNoneIterError */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; #ifdef Py_LIMITED_API PyObject *py_basicsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #ifndef Py_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if ((size_t)basicsize < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(result); return NULL; } #endif /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.')) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); return -1; } static void __Pyx_ReleaseBuffer(Py_buffer *view) { PyObject *obj = view->obj; if (!obj) return; if (PyObject_CheckBuffer(obj)) { PyBuffer_Release(view); return; } if ((0)) {} else if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); view->obj = NULL; Py_DECREF(obj); } #endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return ::std::complex< float >(x, y); } #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return x + y*(__pyx_t_float_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { __pyx_t_float_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabsf(b.real) >= fabsf(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { float r = b.imag / b.real; float s = (float)(1.0) / (b.real + b.imag * r); return __pyx_t_float_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { float r = b.real / b.imag; float s = (float)(1.0) / (b.imag + b.real * r); return __pyx_t_float_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else { float denom = b.real * b.real + b.imag * b.imag; return __pyx_t_float_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrtf(z.real*z.real + z.imag*z.imag); #else return hypotf(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; float r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { float denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(a, a); case 3: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, a); case 4: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = powf(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2f(0.0, -1.0); } } else { r = __Pyx_c_abs_float(a); theta = atan2f(a.imag, a.real); } lnr = logf(r); z_r = expf(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cosf(z_theta); z.imag = z_r * sinf(z_theta); return z; } #endif #endif /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return ::std::complex< double >(x, y); } #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return x + y*(__pyx_t_double_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { __pyx_t_double_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabs(b.real) >= fabs(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { double r = b.imag / b.real; double s = (double)(1.0) / (b.real + b.imag * r); return __pyx_t_double_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { double r = b.real / b.imag; double s = (double)(1.0) / (b.imag + b.real * r); return __pyx_t_double_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else { double denom = b.real * b.real + b.imag * b.imag; return __pyx_t_double_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrt(z.real*z.real + z.imag*z.imag); #else return hypot(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; double r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { double denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(a, a); case 3: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, a); case 4: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = pow(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2(0.0, -1.0); } } else { r = __Pyx_c_abs_double(a); theta = atan2(a.imag, a.real); } lnr = log(r); z_r = exp(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cos(z_theta); z.imag = z_r * sin(z_theta); return z; } #endif #endif /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(enum NPY_TYPES) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(enum NPY_TYPES) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntFromPy */ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (unsigned int) 1), const_zero = (unsigned int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(unsigned int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (unsigned int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned int) 0; case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0]) case 2: if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) { return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; case 3: if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) { return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; case 4: if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT) { return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (unsigned int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(unsigned int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned int) 0; case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, +digits[0]) case -2: if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 2: if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case -3: if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 3: if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case -4: if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 4: if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; } #endif if (sizeof(unsigned int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else unsigned int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (unsigned int) -1; } } else { unsigned int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (unsigned int) -1; val = __Pyx_PyInt_As_unsigned_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned int"); return (unsigned int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned int"); return (unsigned int) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i= 0x02070000 if (!PyCapsule_IsValid(cobj, sig)) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj)); goto bad; } tmp.p = PyCapsule_GetPointer(cobj, sig); #else {const char *desc, *s1, *s2; desc = (const char *)PyCObject_GetDesc(cobj); if (!desc) goto bad; s1 = desc; s2 = sig; while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } if (*s1 != *s2) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", PyModule_GetName(module), funcname, sig, desc); goto bad; } tmp.p = PyCObject_AsVoidPtr(cobj);} #endif *f = tmp.fp; if (!(*f)) goto bad; Py_DECREF(d); return 0; bad: Py_XDECREF(d); return -1; } #endif /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ regions-0.4/regions/_geometry/elliptical_overlap.pyx0000644000076600000240000001544313501414013023137 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst # cython: language_level=3 """ The functions defined here allow one to determine the exact area of overlap of an ellipse and a triangle (written by Thomas Robitaille). The approach is to divide the rectangle into two triangles, and reproject these so that the ellipse is a unit circle, then compute the intersection of a triangle with a unit circle. """ from __future__ import (absolute_import, division, print_function, unicode_literals) import numpy as np cimport numpy as np __all__ = ['elliptical_overlap_grid'] cdef extern from "math.h": double asin(double x) double sin(double x) double cos(double x) double sqrt(double x) from cpython cimport bool DTYPE = np.float64 ctypedef np.float64_t DTYPE_t cimport cython # NOTE: Here we need to make sure we use cimport to import the C functions from # core (since these were defined with cdef). This also requires the core.pxd # file to exist with the function signatures. from .core cimport distance, area_triangle, overlap_area_triangle_unit_circle def elliptical_overlap_grid(double xmin, double xmax, double ymin, double ymax, int nx, int ny, double rx, double ry, double theta, int use_exact, int subpixels): """ elliptical_overlap_grid(xmin, xmax, ymin, ymax, nx, ny, rx, ry, use_exact, subpixels) Area of overlap between an ellipse and a pixel grid. The ellipse is centered on the origin. Parameters ---------- xmin, xmax, ymin, ymax : float Extent of the grid in the x and y direction. nx, ny : int Grid dimensions. rx : float The width axis of the ellipse (without rotation). ry : float The height axis of the ellipse (without rotation). theta : float The rotation of the ellipse in radians (counterclockwise). use_exact : 0 or 1 If set to 1, calculates the exact overlap, while if set to 0, uses a subpixel sampling method with ``subpixel`` subpixels in each direction. subpixels : int If ``use_exact`` is 0, each pixel is resampled by this factor in each dimension. Thus, each pixel is divided into ``subpixels ** 2`` subpixels. Returns ------- frac : `~numpy.ndarray` 2-d array giving the fraction of the overlap. """ cdef unsigned int i, j cdef double x, y, dx, dy cdef double bxmin, bxmax, bymin, bymax cdef double pxmin, pxmax, pymin, pymax cdef double norm # Define output array cdef np.ndarray[DTYPE_t, ndim=2] frac = np.zeros([ny, nx], dtype=DTYPE) # Find the width of each element in x and y dx = (xmax - xmin) / nx dy = (ymax - ymin) / ny norm = 1. / (dx * dy) # For now we use a bounding circle and then use that to find a bounding box # but of course this is inefficient and could be done better. # Find bounding circle radius r = max(rx, ry) # Define bounding box bxmin = -r - 0.5 * dx bxmax = +r + 0.5 * dx bymin = -r - 0.5 * dy bymax = +r + 0.5 * dy for i in range(nx): pxmin = xmin + i * dx # lower end of pixel pxmax = pxmin + dx # upper end of pixel if pxmax > bxmin and pxmin < bxmax: for j in range(ny): pymin = ymin + j * dy pymax = pymin + dy if pymax > bymin and pymin < bymax: if use_exact: frac[j, i] = elliptical_overlap_single_exact( pxmin, pymin, pxmax, pymax, rx, ry, theta) * norm else: frac[j, i] = elliptical_overlap_single_subpixel( pxmin, pymin, pxmax, pymax, rx, ry, theta, subpixels) return frac # NOTE: The following two functions use cdef because they are not # intended to be called from the Python code. Using def makes them # callable from outside, but also slower. In any case, these aren't useful # to call from outside because they only operate on a single pixel. cdef double elliptical_overlap_single_subpixel(double x0, double y0, double x1, double y1, double rx, double ry, double theta, int subpixels): """ Return the fraction of overlap between a ellipse and a single pixel with given extent, using a sub-pixel sampling method. """ cdef unsigned int i, j cdef double x, y cdef double frac = 0. # Accumulator. cdef double inv_rx_sq, inv_ry_sq cdef double cos_theta = cos(theta) cdef double sin_theta = sin(theta) cdef double dx, dy cdef double x_tr, y_tr dx = (x1 - x0) / subpixels dy = (y1 - y0) / subpixels inv_rx_sq = 1. / (rx * rx) inv_ry_sq = 1. / (ry * ry) x = x0 - 0.5 * dx for i in range(subpixels): x += dx y = y0 - 0.5 * dy for j in range(subpixels): y += dy # Transform into frame of rotated ellipse x_tr = y * sin_theta + x * cos_theta y_tr = y * cos_theta - x * sin_theta if x_tr * x_tr * inv_rx_sq + y_tr * y_tr * inv_ry_sq < 1.: frac += 1. return frac / (subpixels * subpixels) cdef double elliptical_overlap_single_exact(double xmin, double ymin, double xmax, double ymax, double rx, double ry, double theta): """ Given a rectangle defined by (xmin, ymin, xmax, ymax) and an ellipse with width and height rx and ry respectively, rotation angle theta, and centered at the origin, find the area of overlap. """ cdef double cos_m_theta = cos(-theta) cdef double sin_m_theta = sin(-theta) cdef double scale # Find scale by which the areas will be shrunk scale = rx * ry # Reproject rectangle to frame of reference in which ellipse is a # unit circle x1, y1 = ((xmin * cos_m_theta - ymin * sin_m_theta) / rx, (xmin * sin_m_theta + ymin * cos_m_theta) / ry) x2, y2 = ((xmax * cos_m_theta - ymin * sin_m_theta) / rx, (xmax * sin_m_theta + ymin * cos_m_theta) / ry) x3, y3 = ((xmax * cos_m_theta - ymax * sin_m_theta) / rx, (xmax * sin_m_theta + ymax * cos_m_theta) / ry) x4, y4 = ((xmin * cos_m_theta - ymax * sin_m_theta) / rx, (xmin * sin_m_theta + ymax * cos_m_theta) / ry) # Divide resulting quadrilateral into two triangles and find # intersection with unit circle return (overlap_area_triangle_unit_circle(x1, y1, x2, y2, x3, y3) + overlap_area_triangle_unit_circle(x1, y1, x4, y4, x3, y3)) * scale regions-0.4/regions/_geometry/pnpoly.c0000644000076600000240000124110313501657422020220 0ustar deilstaff00000000000000/* Generated by Cython 0.29.6 */ #define PY_SSIZE_T_CLEAN #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_6" #define CYTHON_HEX_VERSION 0x001D06F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #ifndef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #define PyObject_Unicode PyObject_Str #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_ERR(f_index, lineno, Ln_error) \ { \ __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__regions___geometry__pnpoly #define __PYX_HAVE_API__regions___geometry__pnpoly /* Early includes */ #include #include #include "numpy/arrayobject.h" #include "numpy/ufuncobject.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; /* Header.proto */ #if !defined(CYTHON_CCOMPLEX) #if defined(__cplusplus) #define CYTHON_CCOMPLEX 1 #elif defined(_Complex_I) #define CYTHON_CCOMPLEX 1 #else #define CYTHON_CCOMPLEX 0 #endif #endif #if CYTHON_CCOMPLEX #ifdef __cplusplus #include #else #include #endif #endif #if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) #undef _Complex_I #define _Complex_I 1.0fj #endif static const char *__pyx_f[] = { "regions/_geometry/pnpoly.pyx", "__init__.pxd", "type.pxd", }; /* BufferFormatStructs.proto */ #define IS_UNSIGNED(type) (((type) -1) > 0) struct __Pyx_StructField_; #define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) typedef struct { const char* name; struct __Pyx_StructField_* fields; size_t size; size_t arraysize[8]; int ndim; char typegroup; char is_unsigned; int flags; } __Pyx_TypeInfo; typedef struct __Pyx_StructField_ { __Pyx_TypeInfo* type; const char* name; size_t offset; } __Pyx_StructField; typedef struct { __Pyx_StructField* field; size_t parent_offset; } __Pyx_BufFmt_StackElem; typedef struct { __Pyx_StructField root; __Pyx_BufFmt_StackElem* head; size_t fmt_offset; size_t new_count, enc_count; size_t struct_alignment; int is_complex; char enc_type; char new_packmode; char enc_packmode; char is_valid_array; } __Pyx_BufFmt_Context; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t */ typedef npy_int8 __pyx_t_5numpy_int8_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t */ typedef npy_int16 __pyx_t_5numpy_int16_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< * ctypedef npy_int64 int64_t * #ctypedef npy_int96 int96_t */ typedef npy_int32 __pyx_t_5numpy_int32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< * #ctypedef npy_int96 int96_t * #ctypedef npy_int128 int128_t */ typedef npy_int64 __pyx_t_5numpy_int64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< * ctypedef npy_uint64 uint64_t * #ctypedef npy_uint96 uint96_t */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":786 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< * #ctypedef npy_uint96 uint96_t * #ctypedef npy_uint128 uint128_t */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< * ctypedef npy_float64 float64_t * #ctypedef npy_float80 float80_t */ typedef npy_float32 __pyx_t_5numpy_float32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< * #ctypedef npy_float80 float80_t * #ctypedef npy_float128 float128_t */ typedef npy_float64 __pyx_t_5numpy_float64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t */ typedef npy_long __pyx_t_5numpy_int_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< * ctypedef npy_longlong longlong_t * */ typedef npy_longlong __pyx_t_5numpy_long_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< * * ctypedef npy_ulong uint_t */ typedef npy_longlong __pyx_t_5numpy_longlong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t */ typedef npy_ulong __pyx_t_5numpy_uint_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulonglong_t * */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":806 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< * * ctypedef npy_intp intp_t */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< * ctypedef npy_uintp uintp_t * */ typedef npy_intp __pyx_t_5numpy_intp_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":809 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< * * ctypedef npy_double float_t */ typedef npy_uintp __pyx_t_5numpy_uintp_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t */ typedef npy_double __pyx_t_5numpy_float_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< * ctypedef npy_longdouble longdouble_t * */ typedef npy_double __pyx_t_5numpy_double_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cfloat cfloat_t */ typedef npy_longdouble __pyx_t_5numpy_longdouble_t; /* "regions/_geometry/pnpoly.pxd":8 * cimport numpy as np * * ctypedef np.float64_t DTYPE_t # <<<<<<<<<<<<<< * * cdef int point_in_polygon(double x, double y, np.ndarray[DTYPE_t, ndim=1] vx, np.ndarray[DTYPE_t, ndim=1] vy) */ typedef __pyx_t_5numpy_float64_t __pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t; /* "regions/_geometry/pnpoly.pyx":71 * * DTYPE_BOOL = np.bool * ctypedef np.uint8_t DTYPE_BOOL_t # <<<<<<<<<<<<<< * * */ typedef __pyx_t_5numpy_uint8_t __pyx_t_7regions_9_geometry_6pnpoly_DTYPE_BOOL_t; /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< float > __pyx_t_float_complex; #else typedef float _Complex __pyx_t_float_complex; #endif #else typedef struct { float real, imag; } __pyx_t_float_complex; #endif static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< double > __pyx_t_double_complex; #else typedef double _Complex __pyx_t_double_complex; #endif #else typedef struct { double real, imag; } __pyx_t_double_complex; #endif static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); /*--- Type declarations ---*/ /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< * ctypedef npy_clongdouble clongdouble_t * */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":817 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cdouble complex_t */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":819 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew1(a): */ typedef npy_cdouble __pyx_t_5numpy_complex_t; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* IsLittleEndian.proto */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); /* BufferFormatCheck.proto */ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type); /* BufferGetAndValidate.proto */ #define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ ((obj == Py_None || obj == NULL) ?\ (__Pyx_ZeroBuffer(buf), 0) :\ __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); static void __Pyx_ZeroBuffer(Py_buffer* buf); static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* BufferFallbackError.proto */ static void __Pyx_RaiseBufferFallbackError(void); /* BufferIndexError.proto */ static void __Pyx_RaiseBufferIndexError(int axis); #define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0) /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* None.proto */ static CYTHON_INLINE long __Pyx_mod_long(long, long); /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto #define __PYX_HAVE_RT_ImportType_proto enum __Pyx_ImportType_CheckSize { __Pyx_ImportType_CheckSize_Error = 0, __Pyx_ImportType_CheckSize_Warn = 1, __Pyx_ImportType_CheckSize_Ignore = 2 }; static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* BufferStructDeclare.proto */ typedef struct { Py_ssize_t shape, strides, suboffsets; } __Pyx_Buf_DimInfo; typedef struct { size_t refcount; Py_buffer pybuffer; } __Pyx_Buffer; typedef struct { __Pyx_Buffer *rcbuffer; char *data; __Pyx_Buf_DimInfo diminfo[8]; } __Pyx_LocalBuf_ND; #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); static void __Pyx_ReleaseBuffer(Py_buffer *view); #else #define __Pyx_GetBuffer PyObject_GetBuffer #define __Pyx_ReleaseBuffer PyBuffer_Release #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus #define __Pyx_CREAL(z) ((z).real()) #define __Pyx_CIMAG(z) ((z).imag()) #else #define __Pyx_CREAL(z) (__real__(z)) #define __Pyx_CIMAG(z) (__imag__(z)) #endif #else #define __Pyx_CREAL(z) ((z).real) #define __Pyx_CIMAG(z) ((z).imag) #endif #if defined(__cplusplus) && CYTHON_CCOMPLEX\ && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) #define __Pyx_SET_CREAL(z,x) ((z).real(x)) #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) #else #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_float(a, b) ((a)==(b)) #define __Pyx_c_sum_float(a, b) ((a)+(b)) #define __Pyx_c_diff_float(a, b) ((a)-(b)) #define __Pyx_c_prod_float(a, b) ((a)*(b)) #define __Pyx_c_quot_float(a, b) ((a)/(b)) #define __Pyx_c_neg_float(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_float(z) ((z)==(float)0) #define __Pyx_c_conj_float(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_float(z) (::std::abs(z)) #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_float(z) ((z)==0) #define __Pyx_c_conj_float(z) (conjf(z)) #if 1 #define __Pyx_c_abs_float(z) (cabsf(z)) #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); #endif #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_double(a, b) ((a)==(b)) #define __Pyx_c_sum_double(a, b) ((a)+(b)) #define __Pyx_c_diff_double(a, b) ((a)-(b)) #define __Pyx_c_prod_double(a, b) ((a)*(b)) #define __Pyx_c_quot_double(a, b) ((a)/(b)) #define __Pyx_c_neg_double(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_double(z) ((z)==(double)0) #define __Pyx_c_conj_double(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_double(z) (::std::abs(z)) #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_double(z) ((z)==0) #define __Pyx_c_conj_double(z) (conj(z)) #if 1 #define __Pyx_c_abs_double(z) (cabs(z)) #define __Pyx_c_pow_double(a, b) (cpow(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); #endif #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* FunctionExport.proto */ static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'cpython.buffer' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdio' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.type' */ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; /* Module declarations from 'cpython' */ /* Module declarations from 'cpython.object' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'cpython.mem' */ /* Module declarations from 'numpy' */ /* Module declarations from 'numpy' */ static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ /* Module declarations from 'regions._geometry.pnpoly' */ static int __pyx_f_7regions_9_geometry_6pnpoly_point_in_polygon(double, double, PyArrayObject *, PyArrayObject *); /*proto*/ static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t = { "DTYPE_t", NULL, sizeof(__pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t), { 0 }, 0, 'R', 0, 0 }; static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_uint8_t = { "uint8_t", NULL, sizeof(__pyx_t_5numpy_uint8_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_uint8_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_uint8_t), 0 }; #define __Pyx_MODULE_NAME "regions._geometry.pnpoly" extern int __pyx_module_is_main_regions___geometry__pnpoly; int __pyx_module_is_main_regions___geometry__pnpoly = 0; /* Implementation of 'regions._geometry.pnpoly' */ static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_ImportError; static const char __pyx_k_i[] = "i"; static const char __pyx_k_n[] = "n"; static const char __pyx_k_x[] = "x"; static const char __pyx_k_y[] = "y"; static const char __pyx_k_np[] = "np"; static const char __pyx_k_vx[] = "vx"; static const char __pyx_k_vy[] = "vy"; static const char __pyx_k_bool[] = "bool"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_zeros[] = "zeros"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_result[] = "result"; static const char __pyx_k_DTYPE_BOOL[] = "DTYPE_BOOL"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_RuntimeError[] = "RuntimeError"; static const char __pyx_k_points_in_polygon[] = "points_in_polygon"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_regions__geometry_pnpoly[] = "regions._geometry.pnpoly"; static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; static const char __pyx_k_regions__geometry_pnpoly_pyx[] = "regions/_geometry/pnpoly.pyx"; static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; static PyObject *__pyx_n_s_DTYPE_BOOL; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; static PyObject *__pyx_n_s_RuntimeError; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_bool; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_i; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_n; static PyObject *__pyx_n_s_name; static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; static PyObject *__pyx_n_s_points_in_polygon; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_regions__geometry_pnpoly; static PyObject *__pyx_kp_s_regions__geometry_pnpoly_pyx; static PyObject *__pyx_n_s_result; static PyObject *__pyx_n_s_test; static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; static PyObject *__pyx_n_s_vx; static PyObject *__pyx_n_s_vy; static PyObject *__pyx_n_s_x; static PyObject *__pyx_n_s_y; static PyObject *__pyx_n_s_zeros; static PyObject *__pyx_pf_7regions_9_geometry_6pnpoly_points_in_polygon(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_x, PyArrayObject *__pyx_v_y, PyArrayObject *__pyx_v_vx, PyArrayObject *__pyx_v_vy); /* proto */ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_codeobj__9; /* Late includes */ /* "regions/_geometry/pnpoly.pyx":74 * * * def points_in_polygon(np.ndarray[DTYPE_t, ndim=1] x, # <<<<<<<<<<<<<< * np.ndarray[DTYPE_t, ndim=1] y, * np.ndarray[DTYPE_t, ndim=1] vx, */ /* Python wrapper */ static PyObject *__pyx_pw_7regions_9_geometry_6pnpoly_1points_in_polygon(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_7regions_9_geometry_6pnpoly_1points_in_polygon = {"points_in_polygon", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7regions_9_geometry_6pnpoly_1points_in_polygon, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_7regions_9_geometry_6pnpoly_1points_in_polygon(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyArrayObject *__pyx_v_x = 0; PyArrayObject *__pyx_v_y = 0; PyArrayObject *__pyx_v_vx = 0; PyArrayObject *__pyx_v_vy = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("points_in_polygon (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_vx,&__pyx_n_s_vy,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("points_in_polygon", 1, 4, 4, 1); __PYX_ERR(0, 74, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_vx)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("points_in_polygon", 1, 4, 4, 2); __PYX_ERR(0, 74, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_vy)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("points_in_polygon", 1, 4, 4, 3); __PYX_ERR(0, 74, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "points_in_polygon") < 0)) __PYX_ERR(0, 74, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_x = ((PyArrayObject *)values[0]); __pyx_v_y = ((PyArrayObject *)values[1]); __pyx_v_vx = ((PyArrayObject *)values[2]); __pyx_v_vy = ((PyArrayObject *)values[3]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("points_in_polygon", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 74, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("regions._geometry.pnpoly.points_in_polygon", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_x), __pyx_ptype_5numpy_ndarray, 1, "x", 0))) __PYX_ERR(0, 74, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_5numpy_ndarray, 1, "y", 0))) __PYX_ERR(0, 75, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vx), __pyx_ptype_5numpy_ndarray, 1, "vx", 0))) __PYX_ERR(0, 76, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vy), __pyx_ptype_5numpy_ndarray, 1, "vy", 0))) __PYX_ERR(0, 77, __pyx_L1_error) __pyx_r = __pyx_pf_7regions_9_geometry_6pnpoly_points_in_polygon(__pyx_self, __pyx_v_x, __pyx_v_y, __pyx_v_vx, __pyx_v_vy); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7regions_9_geometry_6pnpoly_points_in_polygon(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_x, PyArrayObject *__pyx_v_y, PyArrayObject *__pyx_v_vx, PyArrayObject *__pyx_v_vy) { int __pyx_v_i; int __pyx_v_n; PyArrayObject *__pyx_v_result = 0; __Pyx_LocalBuf_ND __pyx_pybuffernd_result; __Pyx_Buffer __pyx_pybuffer_result; __Pyx_LocalBuf_ND __pyx_pybuffernd_vx; __Pyx_Buffer __pyx_pybuffer_vx; __Pyx_LocalBuf_ND __pyx_pybuffernd_vy; __Pyx_Buffer __pyx_pybuffer_vy; __Pyx_LocalBuf_ND __pyx_pybuffernd_x; __Pyx_Buffer __pyx_pybuffer_x; __Pyx_LocalBuf_ND __pyx_pybuffernd_y; __Pyx_Buffer __pyx_pybuffer_y; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyArrayObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; int __pyx_t_12; int __pyx_t_13; Py_ssize_t __pyx_t_14; int __pyx_t_15; Py_ssize_t __pyx_t_16; Py_ssize_t __pyx_t_17; __Pyx_RefNannySetupContext("points_in_polygon", 0); __pyx_pybuffer_result.pybuffer.buf = NULL; __pyx_pybuffer_result.refcount = 0; __pyx_pybuffernd_result.data = NULL; __pyx_pybuffernd_result.rcbuffer = &__pyx_pybuffer_result; __pyx_pybuffer_x.pybuffer.buf = NULL; __pyx_pybuffer_x.refcount = 0; __pyx_pybuffernd_x.data = NULL; __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; __pyx_pybuffer_y.pybuffer.buf = NULL; __pyx_pybuffer_y.refcount = 0; __pyx_pybuffernd_y.data = NULL; __pyx_pybuffernd_y.rcbuffer = &__pyx_pybuffer_y; __pyx_pybuffer_vx.pybuffer.buf = NULL; __pyx_pybuffer_vx.refcount = 0; __pyx_pybuffernd_vx.data = NULL; __pyx_pybuffernd_vx.rcbuffer = &__pyx_pybuffer_vx; __pyx_pybuffer_vy.pybuffer.buf = NULL; __pyx_pybuffer_vy.refcount = 0; __pyx_pybuffernd_vy.data = NULL; __pyx_pybuffernd_vy.rcbuffer = &__pyx_pybuffer_vy; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 74, __pyx_L1_error) } __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_y.rcbuffer->pybuffer, (PyObject*)__pyx_v_y, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 74, __pyx_L1_error) } __pyx_pybuffernd_y.diminfo[0].strides = __pyx_pybuffernd_y.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_y.diminfo[0].shape = __pyx_pybuffernd_y.rcbuffer->pybuffer.shape[0]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vx.rcbuffer->pybuffer, (PyObject*)__pyx_v_vx, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 74, __pyx_L1_error) } __pyx_pybuffernd_vx.diminfo[0].strides = __pyx_pybuffernd_vx.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vx.diminfo[0].shape = __pyx_pybuffernd_vx.rcbuffer->pybuffer.shape[0]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vy.rcbuffer->pybuffer, (PyObject*)__pyx_v_vy, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 74, __pyx_L1_error) } __pyx_pybuffernd_vy.diminfo[0].strides = __pyx_pybuffernd_vy.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vy.diminfo[0].shape = __pyx_pybuffernd_vy.rcbuffer->pybuffer.shape[0]; /* "regions/_geometry/pnpoly.pyx":82 * cdef np.ndarray[np.uint8_t, ndim=1, cast=True] result * * n = x.shape[0] # <<<<<<<<<<<<<< * * result = np.zeros(n, DTYPE_BOOL) */ __pyx_v_n = (__pyx_v_x->dimensions[0]); /* "regions/_geometry/pnpoly.pyx":84 * n = x.shape[0] * * result = np.zeros(n, DTYPE_BOOL) # <<<<<<<<<<<<<< * * for i in range(n): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_DTYPE_BOOL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_2, __pyx_t_4}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_2, __pyx_t_4}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; } __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4); __pyx_t_2 = 0; __pyx_t_4 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 84, __pyx_L1_error) __pyx_t_8 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer); __pyx_t_6 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint8_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 1, __pyx_stack); if (unlikely(__pyx_t_6 < 0)) { PyErr_Fetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_v_result, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint8_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 1, __pyx_stack) == -1)) { Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11); __Pyx_RaiseBufferFallbackError(); } else { PyErr_Restore(__pyx_t_9, __pyx_t_10, __pyx_t_11); } __pyx_t_9 = __pyx_t_10 = __pyx_t_11 = 0; } __pyx_pybuffernd_result.diminfo[0].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_result.diminfo[0].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[0]; if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 84, __pyx_L1_error) } __pyx_t_8 = 0; __pyx_v_result = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/pnpoly.pyx":86 * result = np.zeros(n, DTYPE_BOOL) * * for i in range(n): # <<<<<<<<<<<<<< * result[i] = point_in_polygon(x[i], y[i], vx, vy) * */ __pyx_t_6 = __pyx_v_n; __pyx_t_12 = __pyx_t_6; for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { __pyx_v_i = __pyx_t_13; /* "regions/_geometry/pnpoly.pyx":87 * * for i in range(n): * result[i] = point_in_polygon(x[i], y[i], vx, vy) # <<<<<<<<<<<<<< * * return result */ __pyx_t_14 = __pyx_v_i; __pyx_t_15 = -1; if (__pyx_t_14 < 0) { __pyx_t_14 += __pyx_pybuffernd_x.diminfo[0].shape; if (unlikely(__pyx_t_14 < 0)) __pyx_t_15 = 0; } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_x.diminfo[0].shape)) __pyx_t_15 = 0; if (unlikely(__pyx_t_15 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_15); __PYX_ERR(0, 87, __pyx_L1_error) } __pyx_t_16 = __pyx_v_i; __pyx_t_15 = -1; if (__pyx_t_16 < 0) { __pyx_t_16 += __pyx_pybuffernd_y.diminfo[0].shape; if (unlikely(__pyx_t_16 < 0)) __pyx_t_15 = 0; } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_y.diminfo[0].shape)) __pyx_t_15 = 0; if (unlikely(__pyx_t_15 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_15); __PYX_ERR(0, 87, __pyx_L1_error) } __pyx_t_17 = __pyx_v_i; __pyx_t_15 = -1; if (__pyx_t_17 < 0) { __pyx_t_17 += __pyx_pybuffernd_result.diminfo[0].shape; if (unlikely(__pyx_t_17 < 0)) __pyx_t_15 = 0; } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_result.diminfo[0].shape)) __pyx_t_15 = 0; if (unlikely(__pyx_t_15 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_15); __PYX_ERR(0, 87, __pyx_L1_error) } *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_uint8_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_result.diminfo[0].strides) = __pyx_f_7regions_9_geometry_6pnpoly_point_in_polygon((*__Pyx_BufPtrStrided1d(__pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_x.diminfo[0].strides)), (*__Pyx_BufPtrStrided1d(__pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t *, __pyx_pybuffernd_y.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_y.diminfo[0].strides)), ((PyArrayObject *)__pyx_v_vx), ((PyArrayObject *)__pyx_v_vy)); } /* "regions/_geometry/pnpoly.pyx":89 * result[i] = point_in_polygon(x[i], y[i], vx, vy) * * return result # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_result)); __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; /* "regions/_geometry/pnpoly.pyx":74 * * * def points_in_polygon(np.ndarray[DTYPE_t, ndim=1] x, # <<<<<<<<<<<<<< * np.ndarray[DTYPE_t, ndim=1] y, * np.ndarray[DTYPE_t, ndim=1] vx, */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vx.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vy.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("regions._geometry.pnpoly.points_in_polygon", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vx.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vy.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/pnpoly.pyx":92 * * * cdef int point_in_polygon(double x, double y, # <<<<<<<<<<<<<< * np.ndarray[DTYPE_t, ndim=1] vx, * np.ndarray[DTYPE_t, ndim=1] vy): */ static int __pyx_f_7regions_9_geometry_6pnpoly_point_in_polygon(double __pyx_v_x, double __pyx_v_y, PyArrayObject *__pyx_v_vx, PyArrayObject *__pyx_v_vy) { int __pyx_v_i; int __pyx_v_j; int __pyx_v_n; int __pyx_v_result; __Pyx_LocalBuf_ND __pyx_pybuffernd_vx; __Pyx_Buffer __pyx_pybuffer_vx; __Pyx_LocalBuf_ND __pyx_pybuffernd_vy; __Pyx_Buffer __pyx_pybuffer_vy; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; long __pyx_t_4; int __pyx_t_5; Py_ssize_t __pyx_t_6; int __pyx_t_7; Py_ssize_t __pyx_t_8; int __pyx_t_9; Py_ssize_t __pyx_t_10; Py_ssize_t __pyx_t_11; Py_ssize_t __pyx_t_12; __pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t __pyx_t_13; Py_ssize_t __pyx_t_14; Py_ssize_t __pyx_t_15; __pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t __pyx_t_16; Py_ssize_t __pyx_t_17; __Pyx_RefNannySetupContext("point_in_polygon", 0); __pyx_pybuffer_vx.pybuffer.buf = NULL; __pyx_pybuffer_vx.refcount = 0; __pyx_pybuffernd_vx.data = NULL; __pyx_pybuffernd_vx.rcbuffer = &__pyx_pybuffer_vx; __pyx_pybuffer_vy.pybuffer.buf = NULL; __pyx_pybuffer_vy.refcount = 0; __pyx_pybuffernd_vy.data = NULL; __pyx_pybuffernd_vy.rcbuffer = &__pyx_pybuffer_vy; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vx.rcbuffer->pybuffer, (PyObject*)__pyx_v_vx, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 92, __pyx_L1_error) } __pyx_pybuffernd_vx.diminfo[0].strides = __pyx_pybuffernd_vx.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vx.diminfo[0].shape = __pyx_pybuffernd_vx.rcbuffer->pybuffer.shape[0]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vy.rcbuffer->pybuffer, (PyObject*)__pyx_v_vy, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 92, __pyx_L1_error) } __pyx_pybuffernd_vy.diminfo[0].strides = __pyx_pybuffernd_vy.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vy.diminfo[0].shape = __pyx_pybuffernd_vy.rcbuffer->pybuffer.shape[0]; /* "regions/_geometry/pnpoly.pyx":107 * cdef int result * * n = vx.shape[0] # <<<<<<<<<<<<<< * * result = 0 */ __pyx_v_n = (__pyx_v_vx->dimensions[0]); /* "regions/_geometry/pnpoly.pyx":109 * n = vx.shape[0] * * result = 0 # <<<<<<<<<<<<<< * * for i in range(n): */ __pyx_v_result = 0; /* "regions/_geometry/pnpoly.pyx":111 * result = 0 * * for i in range(n): # <<<<<<<<<<<<<< * j = (i + n - 1) % n * if(((vy[i] > y) != (vy[j] > y)) and */ __pyx_t_1 = __pyx_v_n; __pyx_t_2 = __pyx_t_1; for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; /* "regions/_geometry/pnpoly.pyx":112 * * for i in range(n): * j = (i + n - 1) % n # <<<<<<<<<<<<<< * if(((vy[i] > y) != (vy[j] > y)) and * (x < (vx[j] - vx[i]) * (y - vy[i]) / (vy[j] - vy[i]) + vx[i])): */ __pyx_t_4 = ((__pyx_v_i + __pyx_v_n) - 1); if (unlikely(__pyx_v_n == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); __PYX_ERR(0, 112, __pyx_L1_error) } __pyx_v_j = __Pyx_mod_long(__pyx_t_4, __pyx_v_n); /* "regions/_geometry/pnpoly.pyx":113 * for i in range(n): * j = (i + n - 1) % n * if(((vy[i] > y) != (vy[j] > y)) and # <<<<<<<<<<<<<< * (x < (vx[j] - vx[i]) * (y - vy[i]) / (vy[j] - vy[i]) + vx[i])): * result += 1 */ __pyx_t_6 = __pyx_v_i; __pyx_t_7 = -1; if (__pyx_t_6 < 0) { __pyx_t_6 += __pyx_pybuffernd_vy.diminfo[0].shape; if (unlikely(__pyx_t_6 < 0)) __pyx_t_7 = 0; } else if (unlikely(__pyx_t_6 >= __pyx_pybuffernd_vy.diminfo[0].shape)) __pyx_t_7 = 0; if (unlikely(__pyx_t_7 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_7); __PYX_ERR(0, 113, __pyx_L1_error) } __pyx_t_8 = __pyx_v_j; __pyx_t_7 = -1; if (__pyx_t_8 < 0) { __pyx_t_8 += __pyx_pybuffernd_vy.diminfo[0].shape; if (unlikely(__pyx_t_8 < 0)) __pyx_t_7 = 0; } else if (unlikely(__pyx_t_8 >= __pyx_pybuffernd_vy.diminfo[0].shape)) __pyx_t_7 = 0; if (unlikely(__pyx_t_7 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_7); __PYX_ERR(0, 113, __pyx_L1_error) } __pyx_t_9 = ((((*__Pyx_BufPtrStrided1d(__pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t *, __pyx_pybuffernd_vy.rcbuffer->pybuffer.buf, __pyx_t_6, __pyx_pybuffernd_vy.diminfo[0].strides)) > __pyx_v_y) != ((*__Pyx_BufPtrStrided1d(__pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t *, __pyx_pybuffernd_vy.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_vy.diminfo[0].strides)) > __pyx_v_y)) != 0); if (__pyx_t_9) { } else { __pyx_t_5 = __pyx_t_9; goto __pyx_L6_bool_binop_done; } /* "regions/_geometry/pnpoly.pyx":114 * j = (i + n - 1) % n * if(((vy[i] > y) != (vy[j] > y)) and * (x < (vx[j] - vx[i]) * (y - vy[i]) / (vy[j] - vy[i]) + vx[i])): # <<<<<<<<<<<<<< * result += 1 * */ __pyx_t_10 = __pyx_v_j; __pyx_t_7 = -1; if (__pyx_t_10 < 0) { __pyx_t_10 += __pyx_pybuffernd_vx.diminfo[0].shape; if (unlikely(__pyx_t_10 < 0)) __pyx_t_7 = 0; } else if (unlikely(__pyx_t_10 >= __pyx_pybuffernd_vx.diminfo[0].shape)) __pyx_t_7 = 0; if (unlikely(__pyx_t_7 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_7); __PYX_ERR(0, 114, __pyx_L1_error) } __pyx_t_11 = __pyx_v_i; __pyx_t_7 = -1; if (__pyx_t_11 < 0) { __pyx_t_11 += __pyx_pybuffernd_vx.diminfo[0].shape; if (unlikely(__pyx_t_11 < 0)) __pyx_t_7 = 0; } else if (unlikely(__pyx_t_11 >= __pyx_pybuffernd_vx.diminfo[0].shape)) __pyx_t_7 = 0; if (unlikely(__pyx_t_7 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_7); __PYX_ERR(0, 114, __pyx_L1_error) } __pyx_t_12 = __pyx_v_i; __pyx_t_7 = -1; if (__pyx_t_12 < 0) { __pyx_t_12 += __pyx_pybuffernd_vy.diminfo[0].shape; if (unlikely(__pyx_t_12 < 0)) __pyx_t_7 = 0; } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_vy.diminfo[0].shape)) __pyx_t_7 = 0; if (unlikely(__pyx_t_7 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_7); __PYX_ERR(0, 114, __pyx_L1_error) } __pyx_t_13 = (((*__Pyx_BufPtrStrided1d(__pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t *, __pyx_pybuffernd_vx.rcbuffer->pybuffer.buf, __pyx_t_10, __pyx_pybuffernd_vx.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t *, __pyx_pybuffernd_vx.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_vx.diminfo[0].strides))) * (__pyx_v_y - (*__Pyx_BufPtrStrided1d(__pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t *, __pyx_pybuffernd_vy.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_vy.diminfo[0].strides)))); __pyx_t_14 = __pyx_v_j; __pyx_t_7 = -1; if (__pyx_t_14 < 0) { __pyx_t_14 += __pyx_pybuffernd_vy.diminfo[0].shape; if (unlikely(__pyx_t_14 < 0)) __pyx_t_7 = 0; } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_vy.diminfo[0].shape)) __pyx_t_7 = 0; if (unlikely(__pyx_t_7 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_7); __PYX_ERR(0, 114, __pyx_L1_error) } __pyx_t_15 = __pyx_v_i; __pyx_t_7 = -1; if (__pyx_t_15 < 0) { __pyx_t_15 += __pyx_pybuffernd_vy.diminfo[0].shape; if (unlikely(__pyx_t_15 < 0)) __pyx_t_7 = 0; } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_vy.diminfo[0].shape)) __pyx_t_7 = 0; if (unlikely(__pyx_t_7 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_7); __PYX_ERR(0, 114, __pyx_L1_error) } __pyx_t_16 = ((*__Pyx_BufPtrStrided1d(__pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t *, __pyx_pybuffernd_vy.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_vy.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t *, __pyx_pybuffernd_vy.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_vy.diminfo[0].strides))); if (unlikely(__pyx_t_16 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 114, __pyx_L1_error) } __pyx_t_17 = __pyx_v_i; __pyx_t_7 = -1; if (__pyx_t_17 < 0) { __pyx_t_17 += __pyx_pybuffernd_vx.diminfo[0].shape; if (unlikely(__pyx_t_17 < 0)) __pyx_t_7 = 0; } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_vx.diminfo[0].shape)) __pyx_t_7 = 0; if (unlikely(__pyx_t_7 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_7); __PYX_ERR(0, 114, __pyx_L1_error) } __pyx_t_9 = ((__pyx_v_x < ((__pyx_t_13 / __pyx_t_16) + (*__Pyx_BufPtrStrided1d(__pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t *, __pyx_pybuffernd_vx.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_vx.diminfo[0].strides)))) != 0); __pyx_t_5 = __pyx_t_9; __pyx_L6_bool_binop_done:; /* "regions/_geometry/pnpoly.pyx":113 * for i in range(n): * j = (i + n - 1) % n * if(((vy[i] > y) != (vy[j] > y)) and # <<<<<<<<<<<<<< * (x < (vx[j] - vx[i]) * (y - vy[i]) / (vy[j] - vy[i]) + vx[i])): * result += 1 */ if (__pyx_t_5) { /* "regions/_geometry/pnpoly.pyx":115 * if(((vy[i] > y) != (vy[j] > y)) and * (x < (vx[j] - vx[i]) * (y - vy[i]) / (vy[j] - vy[i]) + vx[i])): * result += 1 # <<<<<<<<<<<<<< * * return result % 2 */ __pyx_v_result = (__pyx_v_result + 1); /* "regions/_geometry/pnpoly.pyx":113 * for i in range(n): * j = (i + n - 1) % n * if(((vy[i] > y) != (vy[j] > y)) and # <<<<<<<<<<<<<< * (x < (vx[j] - vx[i]) * (y - vy[i]) / (vy[j] - vy[i]) + vx[i])): * result += 1 */ } } /* "regions/_geometry/pnpoly.pyx":117 * result += 1 * * return result % 2 # <<<<<<<<<<<<<< */ __pyx_r = __Pyx_mod_long(__pyx_v_result, 2); goto __pyx_L0; /* "regions/_geometry/pnpoly.pyx":92 * * * cdef int point_in_polygon(double x, double y, # <<<<<<<<<<<<<< * np.ndarray[DTYPE_t, ndim=1] vx, * np.ndarray[DTYPE_t, ndim=1] vy): */ /* function exit code */ __pyx_L1_error:; { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vx.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vy.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_WriteUnraisable("regions._geometry.pnpoly.point_in_polygon", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vx.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vy.rcbuffer->pybuffer); __pyx_L2:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< * # This implementation of getbuffer is geared towards Cython * # requirements, and does not yet fulfill the PEP. */ /* Python wrapper */ static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_v_i; int __pyx_v_ndim; int __pyx_v_endian_detector; int __pyx_v_little_endian; int __pyx_v_t; char *__pyx_v_f; PyArray_Descr *__pyx_v_descr = 0; int __pyx_v_offset; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyArray_Descr *__pyx_t_7; PyObject *__pyx_t_8 = NULL; char *__pyx_t_9; if (__pyx_v_info == NULL) { PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); return -1; } __Pyx_RefNannySetupContext("__getbuffer__", 0); __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 * * cdef int i, ndim * cdef int endian_detector = 1 # <<<<<<<<<<<<<< * cdef bint little_endian = ((&endian_detector)[0] != 0) * */ __pyx_v_endian_detector = 1; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 * cdef int i, ndim * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * * ndim = PyArray_NDIM(self) */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 * cdef bint little_endian = ((&endian_detector)[0] != 0) * * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) */ __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< * raise ValueError(u"ndarray is not C contiguous") * */ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 272, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L7_bool_binop_done; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< * raise ValueError(u"ndarray is not Fortran contiguous") * */ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L7_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 276, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 * raise ValueError(u"ndarray is not Fortran contiguous") * * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 * * info.buf = PyArray_DATA(self) * info.ndim = ndim # <<<<<<<<<<<<<< * if sizeof(npy_intp) != sizeof(Py_ssize_t): * # Allocate new buffer for strides and shape info. */ __pyx_v_info->ndim = __pyx_v_ndim; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. */ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< * info.shape = info.strides + ndim * for i in range(ndim): */ __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim # <<<<<<<<<<<<<< * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] */ __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim * for i in range(ndim): # <<<<<<<<<<<<<< * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] */ __pyx_t_4 = __pyx_v_ndim; __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286 * info.shape = info.strides + ndim * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< * info.shape[i] = PyArray_DIMS(self)[i] * else: */ (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287 * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< * else: * info.strides = PyArray_STRIDES(self) */ (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. */ goto __pyx_L9; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289 * info.shape[i] = PyArray_DIMS(self)[i] * else: * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL */ /*else*/ { __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 * else: * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) */ __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); } __pyx_L9:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL # <<<<<<<<<<<<<< * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) */ __pyx_v_info->suboffsets = NULL; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< * info.readonly = not PyArray_ISWRITEABLE(self) * */ __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< * * cdef int t */ __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296 * * cdef int t * cdef char* f = NULL # <<<<<<<<<<<<<< * cdef dtype descr = PyArray_DESCR(self) * cdef int offset */ __pyx_v_f = NULL; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297 * cdef int t * cdef char* f = NULL * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< * cdef int offset * */ __pyx_t_7 = PyArray_DESCR(__pyx_v_self); __pyx_t_3 = ((PyObject *)__pyx_t_7); __Pyx_INCREF(__pyx_t_3); __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300 * cdef int offset * * info.obj = self # <<<<<<<<<<<<<< * * if not PyDataType_HASFIELDS(descr): */ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or */ __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303 * * if not PyDataType_HASFIELDS(descr): * t = descr.type_num # <<<<<<<<<<<<<< * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): */ __pyx_t_4 = __pyx_v_descr->type_num; __pyx_v_t = __pyx_t_4; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); if (!__pyx_t_2) { goto __pyx_L15_next_or; } else { } __pyx_t_2 = (__pyx_v_little_endian != 0); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L14_bool_binop_done; } __pyx_L15_next_or:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305 * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" */ __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L14_bool_binop_done; } __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L14_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 306, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307 * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" */ switch (__pyx_v_t) { case NPY_BYTE: __pyx_v_f = ((char *)"b"); break; case NPY_UBYTE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308 * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" */ __pyx_v_f = ((char *)"B"); break; case NPY_SHORT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309 * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" */ __pyx_v_f = ((char *)"h"); break; case NPY_USHORT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310 * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" */ __pyx_v_f = ((char *)"H"); break; case NPY_INT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311 * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" */ __pyx_v_f = ((char *)"i"); break; case NPY_UINT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312 * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" */ __pyx_v_f = ((char *)"I"); break; case NPY_LONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313 * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" */ __pyx_v_f = ((char *)"l"); break; case NPY_ULONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314 * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" */ __pyx_v_f = ((char *)"L"); break; case NPY_LONGLONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315 * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" */ __pyx_v_f = ((char *)"q"); break; case NPY_ULONGLONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316 * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" */ __pyx_v_f = ((char *)"Q"); break; case NPY_FLOAT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317 * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" */ __pyx_v_f = ((char *)"f"); break; case NPY_DOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318 * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" */ __pyx_v_f = ((char *)"d"); break; case NPY_LONGDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319 * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" */ __pyx_v_f = ((char *)"g"); break; case NPY_CFLOAT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320 * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" */ __pyx_v_f = ((char *)"Zf"); break; case NPY_CDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321 * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" */ __pyx_v_f = ((char *)"Zd"); break; case NPY_CLONGDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322 * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f = "O" * else: */ __pyx_v_f = ((char *)"Zg"); break; case NPY_OBJECT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323 * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ __pyx_v_f = ((char *)"O"); break; default: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325 * elif t == NPY_OBJECT: f = "O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * info.format = f * return */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 325, __pyx_L1_error) break; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f # <<<<<<<<<<<<<< * return * else: */ __pyx_v_info->format = __pyx_v_f; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327 * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f * return # <<<<<<<<<<<<<< * else: * info.format = PyObject_Malloc(_buffer_format_string_len) */ __pyx_r = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329 * return * else: * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 */ /*else*/ { __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330 * else: * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< * offset = 0 * f = _util_dtypestring(descr, info.format + 1, */ (__pyx_v_info->format[0]) = '^'; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331 * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 # <<<<<<<<<<<<<< * f = _util_dtypestring(descr, info.format + 1, * info.format + _buffer_format_string_len, */ __pyx_v_offset = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332 * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< * info.format + _buffer_format_string_len, * &offset) */ __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error) __pyx_v_f = __pyx_t_9; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335 * info.format + _buffer_format_string_len, * &offset) * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< * * def __releasebuffer__(ndarray self, Py_buffer* info): */ (__pyx_v_f[0]) = '\x00'; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< * # This implementation of getbuffer is geared towards Cython * # requirements, and does not yet fulfill the PEP. */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; if (__pyx_v_info->obj != NULL) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } goto __pyx_L2; __pyx_L0:; if (__pyx_v_info->obj == Py_None) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_descr); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) */ /* Python wrapper */ static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__releasebuffer__", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339 * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) # <<<<<<<<<<<<<< * if sizeof(npy_intp) != sizeof(Py_ssize_t): * PyObject_Free(info.strides) */ PyObject_Free(__pyx_v_info->format); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * PyObject_Free(info.strides) * # info.shape was stored after info.strides in the same block */ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341 * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): * PyObject_Free(info.strides) # <<<<<<<<<<<<<< * # info.shape was stored after info.strides in the same block * */ PyObject_Free(__pyx_v_info->strides); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * PyObject_Free(info.strides) * # info.shape was stored after info.strides in the same block */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":825 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 828, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 831, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * * cdef inline tuple PyDataType_SHAPE(dtype d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< * else: * return () */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_empty_tuple); __pyx_r = __pyx_empty_tuple; goto __pyx_L0; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< * # Recursive utility function used in __getbuffer__ to get format * # string. The new location in the format string is returned. */ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { PyArray_Descr *__pyx_v_child = 0; int __pyx_v_endian_detector; int __pyx_v_little_endian; PyObject *__pyx_v_fields = 0; PyObject *__pyx_v_childname = NULL; PyObject *__pyx_v_new_offset = NULL; PyObject *__pyx_v_t = NULL; char *__pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; int __pyx_t_7; long __pyx_t_8; char *__pyx_t_9; __Pyx_RefNannySetupContext("_util_dtypestring", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847 * * cdef dtype child * cdef int endian_detector = 1 # <<<<<<<<<<<<<< * cdef bint little_endian = ((&endian_detector)[0] != 0) * cdef tuple fields */ __pyx_v_endian_detector = 1; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":848 * cdef dtype child * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * cdef tuple fields * */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< * fields = descr.fields[childname] * child, new_offset = fields */ if (unlikely(__pyx_v_descr->names == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(1, 851, __pyx_L1_error) } __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 851, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852 * * for childname in descr.names: * fields = descr.fields[childname] # <<<<<<<<<<<<<< * child, new_offset = fields * */ if (unlikely(__pyx_v_descr->fields == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 852, __pyx_L1_error) } __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":853 * for childname in descr.names: * fields = descr.fields[childname] * child, new_offset = fields # <<<<<<<<<<<<<< * * if (end - f) - (new_offset - offset[0]) < 15: */ if (likely(__pyx_v_fields != Py_None)) { PyObject* sequence = __pyx_v_fields; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(1, 853, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } else { __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 853, __pyx_L1_error) } if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); __pyx_t_4 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 856, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); if (!__pyx_t_7) { goto __pyx_L8_next_or; } else { } __pyx_t_7 = (__pyx_v_little_endian != 0); if (!__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_L8_next_or:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859 * * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< * raise ValueError(u"Non-native byte order not supported") * # One could encode it in the format string and have Cython */ __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); if (__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_6 = __pyx_t_7; __pyx_L7_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":860 * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * # One could encode it in the format string and have Cython * # complain instead, BUT: < and > in format strings also imply */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 860, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 860, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870 * * # Output padding bytes * while offset[0] < new_offset: # <<<<<<<<<<<<<< * f[0] = 120 # "x"; pad byte * f += 1 */ while (1) { __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_6) break; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871 * # Output padding bytes * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< * f += 1 * offset[0] += 1 */ (__pyx_v_f[0]) = 0x78; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872 * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte * f += 1 # <<<<<<<<<<<<<< * offset[0] += 1 * */ __pyx_v_f = (__pyx_v_f + 1); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":873 * f[0] = 120 # "x"; pad byte * f += 1 * offset[0] += 1 # <<<<<<<<<<<<<< * * offset[0] += child.itemsize */ __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":875 * offset[0] += 1 * * offset[0] += child.itemsize # <<<<<<<<<<<<<< * * if not PyDataType_HASFIELDS(child): */ __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< * t = child.type_num * if end - f < 5: */ __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); if (__pyx_t_6) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 * * if not PyDataType_HASFIELDS(child): * t = child.type_num # <<<<<<<<<<<<<< * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); __pyx_t_4 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short.") * */ __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 880, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short.") * */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883 * * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 98; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884 * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 66; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885 * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x68; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886 * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 72; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887 * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x69; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888 * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 73; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889 * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x6C; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890 * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 76; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891 * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x71; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892 * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 81; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893 * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x66; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894 * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x64; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895 * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x67; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896 * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x66; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897 * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x64; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898 * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x67; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":899 * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(__pyx_t_6)) { (__pyx_v_f[0]) = 79; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901 * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * f += 1 * else: */ /*else*/ { __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 901, __pyx_L1_error) } __pyx_L15:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":902 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * f += 1 # <<<<<<<<<<<<<< * else: * # Cython ignores struct boundary information ("T{...}"), */ __pyx_v_f = (__pyx_v_f + 1); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< * t = child.type_num * if end - f < 5: */ goto __pyx_L13; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906 * # Cython ignores struct boundary information ("T{...}"), * # so don't output it * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< * return f * */ /*else*/ { __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 906, __pyx_L1_error) __pyx_v_f = __pyx_t_9; } __pyx_L13:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< * fields = descr.fields[childname] * child, new_offset = fields */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":907 * # so don't output it * f = _util_dtypestring(child, f, end, offset) * return f # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_f; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< * # Recursive utility function used in __getbuffer__ to get format * # string. The new location in the format string is returned. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_child); __Pyx_XDECREF(__pyx_v_fields); __Pyx_XDECREF(__pyx_v_childname); __Pyx_XDECREF(__pyx_v_new_offset); __Pyx_XDECREF(__pyx_v_t); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< * PyArray_SetBaseObject(arr, base) * */ Py_INCREF(__pyx_v_base); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1024 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * * cdef inline object get_array_base(ndarray arr): */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< * if base is NULL: * return None */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< * return base * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1030 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< * * # Versions of the import_* functions which are more suitable for */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * _import_array() */ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_array", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036 * cdef inline int import_array() except -1: * try: * _import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1036, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 * try: * _import_array() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.multiarray failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1037, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1038, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1038, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * _import_array() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_umath", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1042, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1043, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1044, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1044, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_ufunc", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1048, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1049, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1050 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1050, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1050, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec_pnpoly(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_pnpoly}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "pnpoly", 0, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_DTYPE_BOOL, __pyx_k_DTYPE_BOOL, sizeof(__pyx_k_DTYPE_BOOL), 0, 0, 1, 1}, {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_bool, __pyx_k_bool, sizeof(__pyx_k_bool), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, {&__pyx_n_s_points_in_polygon, __pyx_k_points_in_polygon, sizeof(__pyx_k_points_in_polygon), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_regions__geometry_pnpoly, __pyx_k_regions__geometry_pnpoly, sizeof(__pyx_k_regions__geometry_pnpoly), 0, 0, 1, 1}, {&__pyx_kp_s_regions__geometry_pnpoly_pyx, __pyx_k_regions__geometry_pnpoly_pyx, sizeof(__pyx_k_regions__geometry_pnpoly_pyx), 0, 0, 1, 0}, {&__pyx_n_s_result, __pyx_k_result, sizeof(__pyx_k_result), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, {&__pyx_n_s_vx, __pyx_k_vx, sizeof(__pyx_k_vx), 0, 0, 1, 1}, {&__pyx_n_s_vy, __pyx_k_vy, sizeof(__pyx_k_vy), 0, 0, 1, 1}, {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 86, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error) __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 856, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1038, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 1038, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 1044, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "regions/_geometry/pnpoly.pyx":74 * * * def points_in_polygon(np.ndarray[DTYPE_t, ndim=1] x, # <<<<<<<<<<<<<< * np.ndarray[DTYPE_t, ndim=1] y, * np.ndarray[DTYPE_t, ndim=1] vx, */ __pyx_tuple__8 = PyTuple_Pack(7, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_vx, __pyx_n_s_vy, __pyx_n_s_i, __pyx_n_s_n, __pyx_n_s_result); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 74, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(4, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_regions__geometry_pnpoly_pyx, __pyx_n_s_points_in_polygon, 74, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 74, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ if (__Pyx_ExportFunction("point_in_polygon", (void (*)(void))__pyx_f_7regions_9_geometry_6pnpoly_point_in_polygon, "int (double, double, PyArrayObject *, PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 sizeof(PyTypeObject), #else sizeof(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error) __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error) __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 918, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #if PY_MAJOR_VERSION < 3 #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC void #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #else #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyObject * #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC initpnpoly(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC initpnpoly(void) #else __Pyx_PyMODINIT_FUNC PyInit_pnpoly(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_pnpoly(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec_pnpoly(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module 'pnpoly' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_pnpoly(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("pnpoly", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_regions___geometry__pnpoly) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "regions._geometry.pnpoly")) { if (unlikely(PyDict_SetItemString(modules, "regions._geometry.pnpoly", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); if (unlikely(__Pyx_modinit_function_export_code() != 0)) goto __pyx_L1_error; (void)__Pyx_modinit_type_init_code(); if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error; (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "regions/_geometry/pnpoly.pyx":67 * # SOFTWARE. * * import numpy as np # <<<<<<<<<<<<<< * cimport numpy as np * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 67, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/pnpoly.pyx":70 * cimport numpy as np * * DTYPE_BOOL = np.bool # <<<<<<<<<<<<<< * ctypedef np.uint8_t DTYPE_BOOL_t * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_bool); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE_BOOL, __pyx_t_2) < 0) __PYX_ERR(0, 70, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/pnpoly.pyx":74 * * * def points_in_polygon(np.ndarray[DTYPE_t, ndim=1] x, # <<<<<<<<<<<<<< * np.ndarray[DTYPE_t, ndim=1] y, * np.ndarray[DTYPE_t, ndim=1] vx, */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7regions_9_geometry_6pnpoly_1points_in_polygon, NULL, __pyx_n_s_regions__geometry_pnpoly); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 74, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_points_in_polygon, __pyx_t_2) < 0) __PYX_ERR(0, 74, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/pnpoly.pyx":1 * # Licensed under a 3-clause BSD style license - see LICENSE.rst # <<<<<<<<<<<<<< * # cython: language_level=3 * # */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init regions._geometry.pnpoly", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init regions._geometry.pnpoly"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* ArgTypeTest */ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } else if (exact) { #if PY_MAJOR_VERSION == 2 if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; #endif } else { if (likely(__Pyx_TypeCheck(obj, type))) return 1; } PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", name, type->tp_name, Py_TYPE(obj)->tp_name); return 0; } /* IsLittleEndian */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) { union { uint32_t u32; uint8_t u8[4]; } S; S.u32 = 0x01020304; return S.u8[0] == 4; } /* BufferFormatCheck */ static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type) { stack[0].field = &ctx->root; stack[0].parent_offset = 0; ctx->root.type = type; ctx->root.name = "buffer dtype"; ctx->root.offset = 0; ctx->head = stack; ctx->head->field = &ctx->root; ctx->fmt_offset = 0; ctx->head->parent_offset = 0; ctx->new_packmode = '@'; ctx->enc_packmode = '@'; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->is_complex = 0; ctx->is_valid_array = 0; ctx->struct_alignment = 0; while (type->typegroup == 'S') { ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = 0; type = type->fields->type; } } static int __Pyx_BufFmt_ParseNumber(const char** ts) { int count; const char* t = *ts; if (*t < '0' || *t > '9') { return -1; } else { count = *t++ - '0'; while (*t >= '0' && *t <= '9') { count *= 10; count += *t++ - '0'; } } *ts = t; return count; } static int __Pyx_BufFmt_ExpectNumber(const char **ts) { int number = __Pyx_BufFmt_ParseNumber(ts); if (number == -1) PyErr_Format(PyExc_ValueError,\ "Does not understand character buffer dtype format string ('%c')", **ts); return number; } static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { PyErr_Format(PyExc_ValueError, "Unexpected format string character: '%c'", ch); } static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { switch (ch) { case 'c': return "'char'"; case 'b': return "'signed char'"; case 'B': return "'unsigned char'"; case 'h': return "'short'"; case 'H': return "'unsigned short'"; case 'i': return "'int'"; case 'I': return "'unsigned int'"; case 'l': return "'long'"; case 'L': return "'unsigned long'"; case 'q': return "'long long'"; case 'Q': return "'unsigned long long'"; case 'f': return (is_complex ? "'complex float'" : "'float'"); case 'd': return (is_complex ? "'complex double'" : "'double'"); case 'g': return (is_complex ? "'complex long double'" : "'long double'"); case 'T': return "a struct"; case 'O': return "Python object"; case 'P': return "a pointer"; case 's': case 'p': return "a string"; case 0: return "end"; default: return "unparseable format string"; } } static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return 2; case 'i': case 'I': case 'l': case 'L': return 4; case 'q': case 'Q': return 8; case 'f': return (is_complex ? 8 : 4); case 'd': return (is_complex ? 16 : 8); case 'g': { PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); return 0; } case 'O': case 'P': return sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { switch (ch) { case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(short); case 'i': case 'I': return sizeof(int); case 'l': case 'L': return sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(float) * (is_complex ? 2 : 1); case 'd': return sizeof(double) * (is_complex ? 2 : 1); case 'g': return sizeof(long double) * (is_complex ? 2 : 1); case 'O': case 'P': return sizeof(void*); default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } typedef struct { char c; short x; } __Pyx_st_short; typedef struct { char c; int x; } __Pyx_st_int; typedef struct { char c; long x; } __Pyx_st_long; typedef struct { char c; float x; } __Pyx_st_float; typedef struct { char c; double x; } __Pyx_st_double; typedef struct { char c; long double x; } __Pyx_st_longdouble; typedef struct { char c; void *x; } __Pyx_st_void_p; #ifdef HAVE_LONG_LONG typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_st_float) - sizeof(float); case 'd': return sizeof(__Pyx_st_double) - sizeof(double); case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } /* These are for computing the padding at the end of the struct to align on the first member of the struct. This will probably the same as above, but we don't have any guarantees. */ typedef struct { short x; char c; } __Pyx_pad_short; typedef struct { int x; char c; } __Pyx_pad_int; typedef struct { long x; char c; } __Pyx_pad_long; typedef struct { float x; char c; } __Pyx_pad_float; typedef struct { double x; char c; } __Pyx_pad_double; typedef struct { long double x; char c; } __Pyx_pad_longdouble; typedef struct { void *x; char c; } __Pyx_pad_void_p; #ifdef HAVE_LONG_LONG typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { switch (ch) { case 'c': return 'H'; case 'b': case 'h': case 'i': case 'l': case 'q': case 's': case 'p': return 'I'; case 'B': case 'H': case 'I': case 'L': case 'Q': return 'U'; case 'f': case 'd': case 'g': return (is_complex ? 'C' : 'R'); case 'O': return 'O'; case 'P': return 'P'; default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { if (ctx->head == NULL || ctx->head->field == &ctx->root) { const char* expected; const char* quote; if (ctx->head == NULL) { expected = "end"; quote = ""; } else { expected = ctx->head->field->type->name; quote = "'"; } PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected %s%s%s but got %s", quote, expected, quote, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); } else { __Pyx_StructField* field = ctx->head->field; __Pyx_StructField* parent = (ctx->head - 1)->field; PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), parent->type->name, field->name); } } static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { char group; size_t size, offset, arraysize = 1; if (ctx->enc_type == 0) return 0; if (ctx->head->field->type->arraysize[0]) { int i, ndim = 0; if (ctx->enc_type == 's' || ctx->enc_type == 'p') { ctx->is_valid_array = ctx->head->field->type->ndim == 1; ndim = 1; if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %zu", ctx->head->field->type->arraysize[0], ctx->enc_count); return -1; } } if (!ctx->is_valid_array) { PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", ctx->head->field->type->ndim, ndim); return -1; } for (i = 0; i < ctx->head->field->type->ndim; i++) { arraysize *= ctx->head->field->type->arraysize[i]; } ctx->is_valid_array = 0; ctx->enc_count = 1; } group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); do { __Pyx_StructField* field = ctx->head->field; __Pyx_TypeInfo* type = field->type; if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); } else { size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); } if (ctx->enc_packmode == '@') { size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); size_t align_mod_offset; if (align_at == 0) return -1; align_mod_offset = ctx->fmt_offset % align_at; if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; if (ctx->struct_alignment == 0) ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, ctx->is_complex); } if (type->size != size || type->typegroup != group) { if (type->typegroup == 'C' && type->fields != NULL) { size_t parent_offset = ctx->head->parent_offset + field->offset; ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = parent_offset; continue; } if ((type->typegroup == 'H' || group == 'H') && type->size == size) { } else { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } } offset = ctx->head->parent_offset + field->offset; if (ctx->fmt_offset != offset) { PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); return -1; } ctx->fmt_offset += size; if (arraysize) ctx->fmt_offset += (arraysize - 1) * size; --ctx->enc_count; while (1) { if (field == &ctx->root) { ctx->head = NULL; if (ctx->enc_count != 0) { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } break; } ctx->head->field = ++field; if (field->type == NULL) { --ctx->head; field = ctx->head->field; continue; } else if (field->type->typegroup == 'S') { size_t parent_offset = ctx->head->parent_offset + field->offset; if (field->type->fields->type == NULL) continue; field = field->type->fields; ++ctx->head; ctx->head->field = field; ctx->head->parent_offset = parent_offset; break; } else { break; } } } while (ctx->enc_count); ctx->enc_type = 0; ctx->is_complex = 0; return 0; } static PyObject * __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { const char *ts = *tsp; int i = 0, number; int ndim = ctx->head->field->type->ndim; ; ++ts; if (ctx->new_count != 1) { PyErr_SetString(PyExc_ValueError, "Cannot handle repeated arrays in format string"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; while (*ts && *ts != ')') { switch (*ts) { case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; default: break; } number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) return PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %d", ctx->head->field->type->arraysize[i], number); if (*ts != ',' && *ts != ')') return PyErr_Format(PyExc_ValueError, "Expected a comma in format string, got '%c'", *ts); if (*ts == ',') ts++; i++; } if (i != ndim) return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", ctx->head->field->type->ndim, i); if (!*ts) { PyErr_SetString(PyExc_ValueError, "Unexpected end of format string, expected ')'"); return NULL; } ctx->is_valid_array = 1; ctx->new_count = 1; *tsp = ++ts; return Py_None; } static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { int got_Z = 0; while (1) { switch(*ts) { case 0: if (ctx->enc_type != 0 && ctx->head == NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; if (ctx->head != NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } return ts; case ' ': case '\r': case '\n': ++ts; break; case '<': if (!__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '>': case '!': if (__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '=': case '@': case '^': ctx->new_packmode = *ts++; break; case 'T': { const char* ts_after_sub; size_t i, struct_count = ctx->new_count; size_t struct_alignment = ctx->struct_alignment; ctx->new_count = 1; ++ts; if (*ts != '{') { PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; ctx->enc_count = 0; ctx->struct_alignment = 0; ++ts; ts_after_sub = ts; for (i = 0; i != struct_count; ++i) { ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); if (!ts_after_sub) return NULL; } ts = ts_after_sub; if (struct_alignment) ctx->struct_alignment = struct_alignment; } break; case '}': { size_t alignment = ctx->struct_alignment; ++ts; if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; if (alignment && ctx->fmt_offset % alignment) { ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); } } return ts; case 'x': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->fmt_offset += ctx->new_count; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->enc_packmode = ctx->new_packmode; ++ts; break; case 'Z': got_Z = 1; ++ts; if (*ts != 'f' && *ts != 'd' && *ts != 'g') { __Pyx_BufFmt_RaiseUnexpectedChar('Z'); return NULL; } CYTHON_FALLTHROUGH; case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': case 'l': case 'L': case 'q': case 'Q': case 'f': case 'd': case 'g': case 'O': case 'p': if (ctx->enc_type == *ts && got_Z == ctx->is_complex && ctx->enc_packmode == ctx->new_packmode) { ctx->enc_count += ctx->new_count; ctx->new_count = 1; got_Z = 0; ++ts; break; } CYTHON_FALLTHROUGH; case 's': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_count = ctx->new_count; ctx->enc_packmode = ctx->new_packmode; ctx->enc_type = *ts; ctx->is_complex = got_Z; ++ts; ctx->new_count = 1; got_Z = 0; break; case ':': ++ts; while(*ts != ':') ++ts; ++ts; break; case '(': if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; break; default: { int number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; ctx->new_count = (size_t)number; } } } } /* BufferGetAndValidate */ static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { if (unlikely(info->buf == NULL)) return; if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; __Pyx_ReleaseBuffer(info); } static void __Pyx_ZeroBuffer(Py_buffer* buf) { buf->buf = NULL; buf->obj = NULL; buf->strides = __Pyx_zeros; buf->shape = __Pyx_zeros; buf->suboffsets = __Pyx_minusones; } static int __Pyx__GetBufferAndValidate( Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack) { buf->buf = NULL; if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { __Pyx_ZeroBuffer(buf); return -1; } if (unlikely(buf->ndim != nd)) { PyErr_Format(PyExc_ValueError, "Buffer has wrong number of dimensions (expected %d, got %d)", nd, buf->ndim); goto fail; } if (!cast) { __Pyx_BufFmt_Context ctx; __Pyx_BufFmt_Init(&ctx, stack, dtype); if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; } if (unlikely((size_t)buf->itemsize != dtype->size)) { PyErr_Format(PyExc_ValueError, "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", buf->itemsize, (buf->itemsize > 1) ? "s" : "", dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); goto fail; } if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; return 0; fail:; __Pyx_SafeReleaseBuffer(buf); return -1; } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* BufferFallbackError */ static void __Pyx_RaiseBufferFallbackError(void) { PyErr_SetString(PyExc_ValueError, "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!"); } /* BufferIndexError */ static void __Pyx_RaiseBufferIndexError(int axis) { PyErr_Format(PyExc_IndexError, "Out of bounds on buffer access (axis %d)", axis); } /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* None */ static CYTHON_INLINE long __Pyx_mod_long(long a, long b) { long r = a % b; r += ((r != 0) & ((r ^ b) < 0)) * b; return r; } /* WriteUnraisableException */ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback, CYTHON_UNUSED int nogil) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_PyThreadState_declare #ifdef WITH_THREAD PyGILState_STATE state; if (nogil) state = PyGILState_Ensure(); #ifdef _MSC_VER else state = (PyGILState_STATE)-1; #endif #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } #ifdef WITH_THREAD if (nogil) PyGILState_Release(state); #endif } /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* DictGetItem */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); if (unlikely(!value)) { if (!PyErr_Occurred()) { if (unlikely(PyTuple_Check(key))) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) { PyErr_SetObject(PyExc_KeyError, args); Py_DECREF(args); } } else { PyErr_SetObject(PyExc_KeyError, key); } } return NULL; } Py_INCREF(value); return value; } #endif /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* RaiseNoneIterError */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; #ifdef Py_LIMITED_API PyObject *py_basicsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #ifndef Py_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if ((size_t)basicsize < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(result); return NULL; } #endif /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.')) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); return -1; } static void __Pyx_ReleaseBuffer(Py_buffer *view) { PyObject *obj = view->obj; if (!obj) return; if (PyObject_CheckBuffer(obj)) { PyBuffer_Release(view); return; } if ((0)) {} else if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); view->obj = NULL; Py_DECREF(obj); } #endif /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return ::std::complex< float >(x, y); } #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return x + y*(__pyx_t_float_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { __pyx_t_float_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabsf(b.real) >= fabsf(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { float r = b.imag / b.real; float s = (float)(1.0) / (b.real + b.imag * r); return __pyx_t_float_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { float r = b.real / b.imag; float s = (float)(1.0) / (b.imag + b.real * r); return __pyx_t_float_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else { float denom = b.real * b.real + b.imag * b.imag; return __pyx_t_float_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrtf(z.real*z.real + z.imag*z.imag); #else return hypotf(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; float r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { float denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(a, a); case 3: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, a); case 4: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = powf(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2f(0.0, -1.0); } } else { r = __Pyx_c_abs_float(a); theta = atan2f(a.imag, a.real); } lnr = logf(r); z_r = expf(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cosf(z_theta); z.imag = z_r * sinf(z_theta); return z; } #endif #endif /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return ::std::complex< double >(x, y); } #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return x + y*(__pyx_t_double_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { __pyx_t_double_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabs(b.real) >= fabs(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { double r = b.imag / b.real; double s = (double)(1.0) / (b.real + b.imag * r); return __pyx_t_double_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { double r = b.real / b.imag; double s = (double)(1.0) / (b.imag + b.real * r); return __pyx_t_double_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else { double denom = b.real * b.real + b.imag * b.imag; return __pyx_t_double_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrt(z.real*z.real + z.imag*z.imag); #else return hypot(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; double r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { double denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(a, a); case 3: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, a); case 4: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = pow(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2(0.0, -1.0); } } else { r = __Pyx_c_abs_double(a); theta = atan2(a.imag, a.real); } lnr = log(r); z_r = exp(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cos(z_theta); z.imag = z_r * sin(z_theta); return z; } #endif #endif /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(enum NPY_TYPES) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(enum NPY_TYPES) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i= 0x02070000 cobj = PyCapsule_New(tmp.p, sig, 0); #else cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0); #endif if (!cobj) goto bad; if (PyDict_SetItemString(d, name, cobj) < 0) goto bad; Py_DECREF(cobj); Py_DECREF(d); return 0; bad: Py_XDECREF(cobj); Py_XDECREF(d); return -1; } /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ regions-0.4/regions/_geometry/pnpoly.pxd0000644000076600000240000000052613501414013020555 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst # cython: language_level=3 # This file is needed in order to be able to cimport functions into other Cython files cimport numpy as np ctypedef np.float64_t DTYPE_t cdef int point_in_polygon(double x, double y, np.ndarray[DTYPE_t, ndim=1] vx, np.ndarray[DTYPE_t, ndim=1] vy) regions-0.4/regions/_geometry/pnpoly.pyx0000644000076600000240000001045313501414013020602 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst # cython: language_level=3 # # The code in this file was adapted from code written by Greg von Winckel: # # https://github.com/gregvw/pnpoly # # and which was released under the following license: # # ---------------------------------------------------------------------------- # # The MIT License (MIT) # # Copyright (c) 2014 Greg von Winckel # # Permission is hereby granted, free of charge, to any person obtaining a copy of # this software and associated documentation files (the "Software"), to deal in # the Software without restriction, including without limitation the rights to # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of # the Software, and to permit persons to whom the Software is furnished to do so, # subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # # ---------------------------------------------------------------------------- # # This code was itself adapted from code written by W. Randolph Franklin: # # http://www.ecse.rpi.edu/~wrf/Research/Short_Notes/pnpoly.html # # and released under the following license: # # Copyright (c) 1970-2003, Wm. Randolph Franklin # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # Redistributions of source code must retain the above copyright notice, this # list of conditions and the following disclaimers. # # Redistributions in binary form must reproduce the above copyright notice in # the documentation and/or other materials provided with the distribution. # # The name of W. Randolph Franklin may not be used to endorse or promote # products derived from this Software without specific prior written permission. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import numpy as np cimport numpy as np DTYPE_BOOL = np.bool ctypedef np.uint8_t DTYPE_BOOL_t def points_in_polygon(np.ndarray[DTYPE_t, ndim=1] x, np.ndarray[DTYPE_t, ndim=1] y, np.ndarray[DTYPE_t, ndim=1] vx, np.ndarray[DTYPE_t, ndim=1] vy): cdef int i, n cdef np.ndarray[np.uint8_t, ndim=1, cast=True] result n = x.shape[0] result = np.zeros(n, DTYPE_BOOL) for i in range(n): result[i] = point_in_polygon(x[i], y[i], vx, vy) return result cdef int point_in_polygon(double x, double y, np.ndarray[DTYPE_t, ndim=1] vx, np.ndarray[DTYPE_t, ndim=1] vy): """ Determine whether a test point (x, y) is within a polygon defined by a set of vertices (vx, vy). This uses the even-odd rule, as described here: https://en.wikipedia.org/wiki/Even–odd_rule """ cdef int i, j, k, m, n cdef int result n = vx.shape[0] result = 0 for i in range(n): j = (i + n - 1) % n if(((vy[i] > y) != (vy[j] > y)) and (x < (vx[j] - vx[i]) * (y - vy[i]) / (vy[j] - vy[i]) + vx[i])): result += 1 return result % 2 regions-0.4/regions/_geometry/polygonal_overlap.c0000644000076600000240000133142413501657417022445 0ustar deilstaff00000000000000/* Generated by Cython 0.29.6 */ #define PY_SSIZE_T_CLEAN #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_6" #define CYTHON_HEX_VERSION 0x001D06F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #ifndef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #define PyObject_Unicode PyObject_Str #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_ERR(f_index, lineno, Ln_error) \ { \ __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__regions___geometry__polygonal_overlap #define __PYX_HAVE_API__regions___geometry__polygonal_overlap /* Early includes */ #include #include #include "numpy/arrayobject.h" #include "numpy/ufuncobject.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; /* Header.proto */ #if !defined(CYTHON_CCOMPLEX) #if defined(__cplusplus) #define CYTHON_CCOMPLEX 1 #elif defined(_Complex_I) #define CYTHON_CCOMPLEX 1 #else #define CYTHON_CCOMPLEX 0 #endif #endif #if CYTHON_CCOMPLEX #ifdef __cplusplus #include #else #include #endif #endif #if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) #undef _Complex_I #define _Complex_I 1.0fj #endif static const char *__pyx_f[] = { "regions/_geometry/polygonal_overlap.pyx", "__init__.pxd", "type.pxd", }; /* BufferFormatStructs.proto */ #define IS_UNSIGNED(type) (((type) -1) > 0) struct __Pyx_StructField_; #define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) typedef struct { const char* name; struct __Pyx_StructField_* fields; size_t size; size_t arraysize[8]; int ndim; char typegroup; char is_unsigned; int flags; } __Pyx_TypeInfo; typedef struct __Pyx_StructField_ { __Pyx_TypeInfo* type; const char* name; size_t offset; } __Pyx_StructField; typedef struct { __Pyx_StructField* field; size_t parent_offset; } __Pyx_BufFmt_StackElem; typedef struct { __Pyx_StructField root; __Pyx_BufFmt_StackElem* head; size_t fmt_offset; size_t new_count, enc_count; size_t struct_alignment; int is_complex; char enc_type; char new_packmode; char enc_packmode; char is_valid_array; } __Pyx_BufFmt_Context; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t */ typedef npy_int8 __pyx_t_5numpy_int8_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t */ typedef npy_int16 __pyx_t_5numpy_int16_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< * ctypedef npy_int64 int64_t * #ctypedef npy_int96 int96_t */ typedef npy_int32 __pyx_t_5numpy_int32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< * #ctypedef npy_int96 int96_t * #ctypedef npy_int128 int128_t */ typedef npy_int64 __pyx_t_5numpy_int64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< * ctypedef npy_uint64 uint64_t * #ctypedef npy_uint96 uint96_t */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":786 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< * #ctypedef npy_uint96 uint96_t * #ctypedef npy_uint128 uint128_t */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< * ctypedef npy_float64 float64_t * #ctypedef npy_float80 float80_t */ typedef npy_float32 __pyx_t_5numpy_float32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< * #ctypedef npy_float80 float80_t * #ctypedef npy_float128 float128_t */ typedef npy_float64 __pyx_t_5numpy_float64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t */ typedef npy_long __pyx_t_5numpy_int_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< * ctypedef npy_longlong longlong_t * */ typedef npy_longlong __pyx_t_5numpy_long_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< * * ctypedef npy_ulong uint_t */ typedef npy_longlong __pyx_t_5numpy_longlong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t */ typedef npy_ulong __pyx_t_5numpy_uint_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulonglong_t * */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":806 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< * * ctypedef npy_intp intp_t */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< * ctypedef npy_uintp uintp_t * */ typedef npy_intp __pyx_t_5numpy_intp_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":809 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< * * ctypedef npy_double float_t */ typedef npy_uintp __pyx_t_5numpy_uintp_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t */ typedef npy_double __pyx_t_5numpy_float_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< * ctypedef npy_longdouble longdouble_t * */ typedef npy_double __pyx_t_5numpy_double_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cfloat cfloat_t */ typedef npy_longdouble __pyx_t_5numpy_longdouble_t; /* "pnpoly.pxd":8 * cimport numpy as np * * ctypedef np.float64_t DTYPE_t # <<<<<<<<<<<<<< * * cdef int point_in_polygon(double x, double y, np.ndarray[DTYPE_t, ndim=1] vx, np.ndarray[DTYPE_t, ndim=1] vy) */ typedef __pyx_t_5numpy_float64_t __pyx_t_7regions_9_geometry_6pnpoly_DTYPE_t; /* "regions/_geometry/polygonal_overlap.pyx":14 * * DTYPE = np.float64 * ctypedef np.float64_t DTYPE_t # <<<<<<<<<<<<<< * * from .pnpoly cimport point_in_polygon */ typedef __pyx_t_5numpy_float64_t __pyx_t_7regions_9_geometry_17polygonal_overlap_DTYPE_t; /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< float > __pyx_t_float_complex; #else typedef float _Complex __pyx_t_float_complex; #endif #else typedef struct { float real, imag; } __pyx_t_float_complex; #endif static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< double > __pyx_t_double_complex; #else typedef double _Complex __pyx_t_double_complex; #endif #else typedef struct { double real, imag; } __pyx_t_double_complex; #endif static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); /*--- Type declarations ---*/ /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< * ctypedef npy_clongdouble clongdouble_t * */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":817 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cdouble complex_t */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":819 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew1(a): */ typedef npy_cdouble __pyx_t_5numpy_complex_t; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* IsLittleEndian.proto */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); /* BufferFormatCheck.proto */ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type); /* BufferGetAndValidate.proto */ #define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ ((obj == Py_None || obj == NULL) ?\ (__Pyx_ZeroBuffer(buf), 0) :\ __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); static void __Pyx_ZeroBuffer(Py_buffer* buf); static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallNoArg.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* BufferIndexError.proto */ static void __Pyx_RaiseBufferIndexError(int axis); #define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1) /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto #define __PYX_HAVE_RT_ImportType_proto enum __Pyx_ImportType_CheckSize { __Pyx_ImportType_CheckSize_Error = 0, __Pyx_ImportType_CheckSize_Warn = 1, __Pyx_ImportType_CheckSize_Ignore = 2 }; static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* BufferStructDeclare.proto */ typedef struct { Py_ssize_t shape, strides, suboffsets; } __Pyx_Buf_DimInfo; typedef struct { size_t refcount; Py_buffer pybuffer; } __Pyx_Buffer; typedef struct { __Pyx_Buffer *rcbuffer; char *data; __Pyx_Buf_DimInfo diminfo[8]; } __Pyx_LocalBuf_ND; #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); static void __Pyx_ReleaseBuffer(Py_buffer *view); #else #define __Pyx_GetBuffer PyObject_GetBuffer #define __Pyx_ReleaseBuffer PyBuffer_Release #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus #define __Pyx_CREAL(z) ((z).real()) #define __Pyx_CIMAG(z) ((z).imag()) #else #define __Pyx_CREAL(z) (__real__(z)) #define __Pyx_CIMAG(z) (__imag__(z)) #endif #else #define __Pyx_CREAL(z) ((z).real) #define __Pyx_CIMAG(z) ((z).imag) #endif #if defined(__cplusplus) && CYTHON_CCOMPLEX\ && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) #define __Pyx_SET_CREAL(z,x) ((z).real(x)) #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) #else #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_float(a, b) ((a)==(b)) #define __Pyx_c_sum_float(a, b) ((a)+(b)) #define __Pyx_c_diff_float(a, b) ((a)-(b)) #define __Pyx_c_prod_float(a, b) ((a)*(b)) #define __Pyx_c_quot_float(a, b) ((a)/(b)) #define __Pyx_c_neg_float(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_float(z) ((z)==(float)0) #define __Pyx_c_conj_float(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_float(z) (::std::abs(z)) #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_float(z) ((z)==0) #define __Pyx_c_conj_float(z) (conjf(z)) #if 1 #define __Pyx_c_abs_float(z) (cabsf(z)) #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); #endif #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_double(a, b) ((a)==(b)) #define __Pyx_c_sum_double(a, b) ((a)+(b)) #define __Pyx_c_diff_double(a, b) ((a)-(b)) #define __Pyx_c_prod_double(a, b) ((a)*(b)) #define __Pyx_c_quot_double(a, b) ((a)/(b)) #define __Pyx_c_neg_double(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_double(z) ((z)==(double)0) #define __Pyx_c_conj_double(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_double(z) (::std::abs(z)) #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_double(z) ((z)==0) #define __Pyx_c_conj_double(z) (conj(z)) #if 1 #define __Pyx_c_abs_double(z) (cabs(z)) #define __Pyx_c_pow_double(a, b) (cpow(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); #endif #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* FunctionImport.proto */ static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'cpython.buffer' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdio' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.type' */ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; /* Module declarations from 'cpython' */ /* Module declarations from 'cpython.object' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'cpython.mem' */ /* Module declarations from 'numpy' */ /* Module declarations from 'numpy' */ static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ /* Module declarations from 'regions._geometry.pnpoly' */ static int (*__pyx_f_7regions_9_geometry_6pnpoly_point_in_polygon)(double, double, PyArrayObject *, PyArrayObject *); /*proto*/ /* Module declarations from 'regions._geometry.polygonal_overlap' */ static double __pyx_f_7regions_9_geometry_17polygonal_overlap_polygonal_overlap_single_subpixel(double, double, double, double, PyArrayObject *, PyArrayObject *, int); /*proto*/ static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_17polygonal_overlap_DTYPE_t = { "DTYPE_t", NULL, sizeof(__pyx_t_7regions_9_geometry_17polygonal_overlap_DTYPE_t), { 0 }, 0, 'R', 0, 0 }; #define __Pyx_MODULE_NAME "regions._geometry.polygonal_overlap" extern int __pyx_module_is_main_regions___geometry__polygonal_overlap; int __pyx_module_is_main_regions___geometry__polygonal_overlap = 0; /* Implementation of 'regions._geometry.polygonal_overlap' */ static PyObject *__pyx_builtin_NotImplementedError; static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_ImportError; static const char __pyx_k_d[] = "d"; static const char __pyx_k_i[] = "i"; static const char __pyx_k_j[] = "j"; static const char __pyx_k_x[] = "x"; static const char __pyx_k_y[] = "y"; static const char __pyx_k_dx[] = "dx"; static const char __pyx_k_dy[] = "dy"; static const char __pyx_k_np[] = "np"; static const char __pyx_k_nx[] = "nx"; static const char __pyx_k_ny[] = "ny"; static const char __pyx_k_vx[] = "vx"; static const char __pyx_k_vy[] = "vy"; static const char __pyx_k_all[] = "__all__"; static const char __pyx_k_max[] = "max"; static const char __pyx_k_min[] = "min"; static const char __pyx_k_frac[] = "frac"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_xmax[] = "xmax"; static const char __pyx_k_xmin[] = "xmin"; static const char __pyx_k_ymax[] = "ymax"; static const char __pyx_k_ymin[] = "ymin"; static const char __pyx_k_DTYPE[] = "DTYPE"; static const char __pyx_k_bxmax[] = "bxmax"; static const char __pyx_k_bxmin[] = "bxmin"; static const char __pyx_k_bymax[] = "bymax"; static const char __pyx_k_bymin[] = "bymin"; static const char __pyx_k_dtype[] = "dtype"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_pxcen[] = "pxcen"; static const char __pyx_k_pxmax[] = "pxmax"; static const char __pyx_k_pxmin[] = "pxmin"; static const char __pyx_k_pycen[] = "pycen"; static const char __pyx_k_pymax[] = "pymax"; static const char __pyx_k_pymin[] = "pymin"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_zeros[] = "zeros"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_float64[] = "float64"; static const char __pyx_k_subpixels[] = "subpixels"; static const char __pyx_k_use_exact[] = "use_exact"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_RuntimeError[] = "RuntimeError"; static const char __pyx_k_pixel_radius[] = "pixel_radius"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_NotImplementedError[] = "NotImplementedError"; static const char __pyx_k_polygonal_overlap_grid[] = "polygonal_overlap_grid"; static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; static const char __pyx_k_Exact_mode_has_not_been_implemen[] = "Exact mode has not been implemented for polygonal apertures"; static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; static const char __pyx_k_regions__geometry_polygonal_over[] = "regions/_geometry/polygonal_overlap.pyx"; static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; static const char __pyx_k_regions__geometry_polygonal_over_2[] = "regions._geometry.polygonal_overlap"; static PyObject *__pyx_n_s_DTYPE; static PyObject *__pyx_kp_u_Exact_mode_has_not_been_implemen; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; static PyObject *__pyx_n_s_NotImplementedError; static PyObject *__pyx_n_s_RuntimeError; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_all; static PyObject *__pyx_n_s_bxmax; static PyObject *__pyx_n_s_bxmin; static PyObject *__pyx_n_s_bymax; static PyObject *__pyx_n_s_bymin; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_d; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_dx; static PyObject *__pyx_n_s_dy; static PyObject *__pyx_n_s_float64; static PyObject *__pyx_n_s_frac; static PyObject *__pyx_n_s_i; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_j; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_max; static PyObject *__pyx_n_s_min; static PyObject *__pyx_n_s_name; static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; static PyObject *__pyx_n_s_nx; static PyObject *__pyx_n_s_ny; static PyObject *__pyx_n_s_pixel_radius; static PyObject *__pyx_n_s_polygonal_overlap_grid; static PyObject *__pyx_n_u_polygonal_overlap_grid; static PyObject *__pyx_n_s_pxcen; static PyObject *__pyx_n_s_pxmax; static PyObject *__pyx_n_s_pxmin; static PyObject *__pyx_n_s_pycen; static PyObject *__pyx_n_s_pymax; static PyObject *__pyx_n_s_pymin; static PyObject *__pyx_n_s_range; static PyObject *__pyx_kp_s_regions__geometry_polygonal_over; static PyObject *__pyx_n_s_regions__geometry_polygonal_over_2; static PyObject *__pyx_n_s_subpixels; static PyObject *__pyx_n_s_test; static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; static PyObject *__pyx_n_s_use_exact; static PyObject *__pyx_n_s_vx; static PyObject *__pyx_n_s_vy; static PyObject *__pyx_n_s_x; static PyObject *__pyx_n_s_xmax; static PyObject *__pyx_n_s_xmin; static PyObject *__pyx_n_s_y; static PyObject *__pyx_n_s_ymax; static PyObject *__pyx_n_s_ymin; static PyObject *__pyx_n_s_zeros; static PyObject *__pyx_pf_7regions_9_geometry_17polygonal_overlap_polygonal_overlap_grid(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_xmin, double __pyx_v_xmax, double __pyx_v_ymin, double __pyx_v_ymax, int __pyx_v_nx, int __pyx_v_ny, PyArrayObject *__pyx_v_vx, PyArrayObject *__pyx_v_vy, int __pyx_v_use_exact, int __pyx_v_subpixels); /* proto */ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; static PyObject *__pyx_codeobj__10; /* Late includes */ /* "regions/_geometry/polygonal_overlap.pyx":21 * * * def polygonal_overlap_grid(double xmin, double xmax, double ymin, double ymax, # <<<<<<<<<<<<<< * int nx, int ny, * np.ndarray[DTYPE_t, ndim=1] vx, */ /* Python wrapper */ static PyObject *__pyx_pw_7regions_9_geometry_17polygonal_overlap_1polygonal_overlap_grid(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7regions_9_geometry_17polygonal_overlap_polygonal_overlap_grid[] = "\n polygonal_overlap_grid(xmin, xmax, ymin, ymax, nx, ny, r,\n use_exact, subpixels)\n\n Area of overlap between a polygon and a pixel grid.\n\n Parameters\n ----------\n xmin, xmax, ymin, ymax : float\n Extent of the grid in the x and y direction.\n nx, ny : int\n Grid dimensions.\n vx, vy : `numpy.ndarray`\n The vertices of the polygon\n use_exact : 0 or 1\n If ``1`` calculates exact overlap, if ``0`` uses ``subpixel`` number\n of subpixels to calculate the overlap.\n subpixels : int\n Each pixel resampled by this factor in each dimension, thus each\n pixel is divided into ``subpixels ** 2`` subpixels.\n\n Returns\n -------\n frac : `~numpy.ndarray` (float)\n 2-d array of shape (ny, nx) giving the fraction of the overlap.\n "; static PyMethodDef __pyx_mdef_7regions_9_geometry_17polygonal_overlap_1polygonal_overlap_grid = {"polygonal_overlap_grid", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7regions_9_geometry_17polygonal_overlap_1polygonal_overlap_grid, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7regions_9_geometry_17polygonal_overlap_polygonal_overlap_grid}; static PyObject *__pyx_pw_7regions_9_geometry_17polygonal_overlap_1polygonal_overlap_grid(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { double __pyx_v_xmin; double __pyx_v_xmax; double __pyx_v_ymin; double __pyx_v_ymax; int __pyx_v_nx; int __pyx_v_ny; PyArrayObject *__pyx_v_vx = 0; PyArrayObject *__pyx_v_vy = 0; int __pyx_v_use_exact; int __pyx_v_subpixels; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("polygonal_overlap_grid (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_xmin,&__pyx_n_s_xmax,&__pyx_n_s_ymin,&__pyx_n_s_ymax,&__pyx_n_s_nx,&__pyx_n_s_ny,&__pyx_n_s_vx,&__pyx_n_s_vy,&__pyx_n_s_use_exact,&__pyx_n_s_subpixels,0}; PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); CYTHON_FALLTHROUGH; case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); CYTHON_FALLTHROUGH; case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); CYTHON_FALLTHROUGH; case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); CYTHON_FALLTHROUGH; case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xmin)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xmax)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("polygonal_overlap_grid", 1, 10, 10, 1); __PYX_ERR(0, 21, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ymin)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("polygonal_overlap_grid", 1, 10, 10, 2); __PYX_ERR(0, 21, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ymax)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("polygonal_overlap_grid", 1, 10, 10, 3); __PYX_ERR(0, 21, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nx)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("polygonal_overlap_grid", 1, 10, 10, 4); __PYX_ERR(0, 21, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ny)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("polygonal_overlap_grid", 1, 10, 10, 5); __PYX_ERR(0, 21, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 6: if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_vx)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("polygonal_overlap_grid", 1, 10, 10, 6); __PYX_ERR(0, 21, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 7: if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_vy)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("polygonal_overlap_grid", 1, 10, 10, 7); __PYX_ERR(0, 21, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 8: if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_use_exact)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("polygonal_overlap_grid", 1, 10, 10, 8); __PYX_ERR(0, 21, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 9: if (likely((values[9] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_subpixels)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("polygonal_overlap_grid", 1, 10, 10, 9); __PYX_ERR(0, 21, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "polygonal_overlap_grid") < 0)) __PYX_ERR(0, 21, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 10) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); values[4] = PyTuple_GET_ITEM(__pyx_args, 4); values[5] = PyTuple_GET_ITEM(__pyx_args, 5); values[6] = PyTuple_GET_ITEM(__pyx_args, 6); values[7] = PyTuple_GET_ITEM(__pyx_args, 7); values[8] = PyTuple_GET_ITEM(__pyx_args, 8); values[9] = PyTuple_GET_ITEM(__pyx_args, 9); } __pyx_v_xmin = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_xmin == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 21, __pyx_L3_error) __pyx_v_xmax = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_xmax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 21, __pyx_L3_error) __pyx_v_ymin = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_ymin == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 21, __pyx_L3_error) __pyx_v_ymax = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_ymax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 21, __pyx_L3_error) __pyx_v_nx = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_nx == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 22, __pyx_L3_error) __pyx_v_ny = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_ny == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 22, __pyx_L3_error) __pyx_v_vx = ((PyArrayObject *)values[6]); __pyx_v_vy = ((PyArrayObject *)values[7]); __pyx_v_use_exact = __Pyx_PyInt_As_int(values[8]); if (unlikely((__pyx_v_use_exact == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 25, __pyx_L3_error) __pyx_v_subpixels = __Pyx_PyInt_As_int(values[9]); if (unlikely((__pyx_v_subpixels == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("polygonal_overlap_grid", 1, 10, 10, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 21, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("regions._geometry.polygonal_overlap.polygonal_overlap_grid", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vx), __pyx_ptype_5numpy_ndarray, 1, "vx", 0))) __PYX_ERR(0, 23, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vy), __pyx_ptype_5numpy_ndarray, 1, "vy", 0))) __PYX_ERR(0, 24, __pyx_L1_error) __pyx_r = __pyx_pf_7regions_9_geometry_17polygonal_overlap_polygonal_overlap_grid(__pyx_self, __pyx_v_xmin, __pyx_v_xmax, __pyx_v_ymin, __pyx_v_ymax, __pyx_v_nx, __pyx_v_ny, __pyx_v_vx, __pyx_v_vy, __pyx_v_use_exact, __pyx_v_subpixels); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7regions_9_geometry_17polygonal_overlap_polygonal_overlap_grid(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_xmin, double __pyx_v_xmax, double __pyx_v_ymin, double __pyx_v_ymax, int __pyx_v_nx, int __pyx_v_ny, PyArrayObject *__pyx_v_vx, PyArrayObject *__pyx_v_vy, int __pyx_v_use_exact, int __pyx_v_subpixels) { unsigned int __pyx_v_i; unsigned int __pyx_v_j; double __pyx_v_dx; double __pyx_v_dy; double __pyx_v_bxmin; double __pyx_v_bxmax; double __pyx_v_bymin; double __pyx_v_bymax; double __pyx_v_pxmin; double __pyx_v_pxmax; double __pyx_v_pymin; double __pyx_v_pymax; PyArrayObject *__pyx_v_frac = 0; __Pyx_LocalBuf_ND __pyx_pybuffernd_frac; __Pyx_Buffer __pyx_pybuffer_frac; __Pyx_LocalBuf_ND __pyx_pybuffernd_vx; __Pyx_Buffer __pyx_pybuffer_vx; __Pyx_LocalBuf_ND __pyx_pybuffernd_vy; __Pyx_Buffer __pyx_pybuffer_vy; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyArrayObject *__pyx_t_5 = NULL; int __pyx_t_6; double __pyx_t_7; int __pyx_t_8; int __pyx_t_9; unsigned int __pyx_t_10; int __pyx_t_11; int __pyx_t_12; int __pyx_t_13; unsigned int __pyx_t_14; size_t __pyx_t_15; size_t __pyx_t_16; int __pyx_t_17; __Pyx_RefNannySetupContext("polygonal_overlap_grid", 0); __pyx_pybuffer_frac.pybuffer.buf = NULL; __pyx_pybuffer_frac.refcount = 0; __pyx_pybuffernd_frac.data = NULL; __pyx_pybuffernd_frac.rcbuffer = &__pyx_pybuffer_frac; __pyx_pybuffer_vx.pybuffer.buf = NULL; __pyx_pybuffer_vx.refcount = 0; __pyx_pybuffernd_vx.data = NULL; __pyx_pybuffernd_vx.rcbuffer = &__pyx_pybuffer_vx; __pyx_pybuffer_vy.pybuffer.buf = NULL; __pyx_pybuffer_vy.refcount = 0; __pyx_pybuffernd_vy.data = NULL; __pyx_pybuffernd_vy.rcbuffer = &__pyx_pybuffer_vy; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vx.rcbuffer->pybuffer, (PyObject*)__pyx_v_vx, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_17polygonal_overlap_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 21, __pyx_L1_error) } __pyx_pybuffernd_vx.diminfo[0].strides = __pyx_pybuffernd_vx.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vx.diminfo[0].shape = __pyx_pybuffernd_vx.rcbuffer->pybuffer.shape[0]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vy.rcbuffer->pybuffer, (PyObject*)__pyx_v_vy, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_17polygonal_overlap_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 21, __pyx_L1_error) } __pyx_pybuffernd_vy.diminfo[0].strides = __pyx_pybuffernd_vy.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vy.diminfo[0].shape = __pyx_pybuffernd_vy.rcbuffer->pybuffer.shape[0]; /* "regions/_geometry/polygonal_overlap.pyx":60 * * # Define output array * cdef np.ndarray[DTYPE_t, ndim=2] frac = np.zeros([ny, nx], dtype=DTYPE) # <<<<<<<<<<<<<< * * if use_exact == 1: */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_ny); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_nx); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_3); PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 60, __pyx_L1_error) __pyx_t_5 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_frac.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_17polygonal_overlap_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) { __pyx_v_frac = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_frac.rcbuffer->pybuffer.buf = NULL; __PYX_ERR(0, 60, __pyx_L1_error) } else {__pyx_pybuffernd_frac.diminfo[0].strides = __pyx_pybuffernd_frac.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_frac.diminfo[0].shape = __pyx_pybuffernd_frac.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_frac.diminfo[1].strides = __pyx_pybuffernd_frac.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_frac.diminfo[1].shape = __pyx_pybuffernd_frac.rcbuffer->pybuffer.shape[1]; } } __pyx_t_5 = 0; __pyx_v_frac = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/polygonal_overlap.pyx":62 * cdef np.ndarray[DTYPE_t, ndim=2] frac = np.zeros([ny, nx], dtype=DTYPE) * * if use_exact == 1: # <<<<<<<<<<<<<< * raise NotImplementedError("Exact mode has not been implemented for " * "polygonal apertures") */ __pyx_t_6 = ((__pyx_v_use_exact == 1) != 0); if (unlikely(__pyx_t_6)) { /* "regions/_geometry/polygonal_overlap.pyx":63 * * if use_exact == 1: * raise NotImplementedError("Exact mode has not been implemented for " # <<<<<<<<<<<<<< * "polygonal apertures") * */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 63, __pyx_L1_error) /* "regions/_geometry/polygonal_overlap.pyx":62 * cdef np.ndarray[DTYPE_t, ndim=2] frac = np.zeros([ny, nx], dtype=DTYPE) * * if use_exact == 1: # <<<<<<<<<<<<<< * raise NotImplementedError("Exact mode has not been implemented for " * "polygonal apertures") */ } /* "regions/_geometry/polygonal_overlap.pyx":67 * * # Find the width of each element in x and y * dx = (xmax - xmin) / nx # <<<<<<<<<<<<<< * dy = (ymax - ymin) / ny * */ __pyx_t_7 = (__pyx_v_xmax - __pyx_v_xmin); if (unlikely(__pyx_v_nx == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 67, __pyx_L1_error) } __pyx_v_dx = (__pyx_t_7 / ((double)__pyx_v_nx)); /* "regions/_geometry/polygonal_overlap.pyx":68 * # Find the width of each element in x and y * dx = (xmax - xmin) / nx * dy = (ymax - ymin) / ny # <<<<<<<<<<<<<< * * # Define bounding box */ __pyx_t_7 = (__pyx_v_ymax - __pyx_v_ymin); if (unlikely(__pyx_v_ny == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 68, __pyx_L1_error) } __pyx_v_dy = (__pyx_t_7 / ((double)__pyx_v_ny)); /* "regions/_geometry/polygonal_overlap.pyx":71 * * # Define bounding box * bxmin = vx.min() # <<<<<<<<<<<<<< * bxmax = vx.max() * bymin = vy.min() */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_vx), __pyx_n_s_min); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_bxmin = __pyx_t_7; /* "regions/_geometry/polygonal_overlap.pyx":72 * # Define bounding box * bxmin = vx.min() * bxmax = vx.max() # <<<<<<<<<<<<<< * bymin = vy.min() * bymax = vy.max() */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_vx), __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 72, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 72, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_bxmax = __pyx_t_7; /* "regions/_geometry/polygonal_overlap.pyx":73 * bxmin = vx.min() * bxmax = vx.max() * bymin = vy.min() # <<<<<<<<<<<<<< * bymax = vy.max() * */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_vy), __pyx_n_s_min); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_bymin = __pyx_t_7; /* "regions/_geometry/polygonal_overlap.pyx":74 * bxmax = vx.max() * bymin = vy.min() * bymax = vy.max() # <<<<<<<<<<<<<< * * for i in range(nx): */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_vy), __pyx_n_s_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 74, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 74, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_bymax = __pyx_t_7; /* "regions/_geometry/polygonal_overlap.pyx":76 * bymax = vy.max() * * for i in range(nx): # <<<<<<<<<<<<<< * pxmin = xmin + i * dx # lower end of pixel * pxmax = pxmin + dx # upper end of pixel */ __pyx_t_8 = __pyx_v_nx; __pyx_t_9 = __pyx_t_8; for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) { __pyx_v_i = __pyx_t_10; /* "regions/_geometry/polygonal_overlap.pyx":77 * * for i in range(nx): * pxmin = xmin + i * dx # lower end of pixel # <<<<<<<<<<<<<< * pxmax = pxmin + dx # upper end of pixel * if pxmax > bxmin and pxmin < bxmax: */ __pyx_v_pxmin = (__pyx_v_xmin + (__pyx_v_i * __pyx_v_dx)); /* "regions/_geometry/polygonal_overlap.pyx":78 * for i in range(nx): * pxmin = xmin + i * dx # lower end of pixel * pxmax = pxmin + dx # upper end of pixel # <<<<<<<<<<<<<< * if pxmax > bxmin and pxmin < bxmax: * for j in range(ny): */ __pyx_v_pxmax = (__pyx_v_pxmin + __pyx_v_dx); /* "regions/_geometry/polygonal_overlap.pyx":79 * pxmin = xmin + i * dx # lower end of pixel * pxmax = pxmin + dx # upper end of pixel * if pxmax > bxmin and pxmin < bxmax: # <<<<<<<<<<<<<< * for j in range(ny): * pymin = ymin + j * dy */ __pyx_t_11 = ((__pyx_v_pxmax > __pyx_v_bxmin) != 0); if (__pyx_t_11) { } else { __pyx_t_6 = __pyx_t_11; goto __pyx_L7_bool_binop_done; } __pyx_t_11 = ((__pyx_v_pxmin < __pyx_v_bxmax) != 0); __pyx_t_6 = __pyx_t_11; __pyx_L7_bool_binop_done:; if (__pyx_t_6) { /* "regions/_geometry/polygonal_overlap.pyx":80 * pxmax = pxmin + dx # upper end of pixel * if pxmax > bxmin and pxmin < bxmax: * for j in range(ny): # <<<<<<<<<<<<<< * pymin = ymin + j * dy * pymax = pymin + dy */ __pyx_t_12 = __pyx_v_ny; __pyx_t_13 = __pyx_t_12; for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { __pyx_v_j = __pyx_t_14; /* "regions/_geometry/polygonal_overlap.pyx":81 * if pxmax > bxmin and pxmin < bxmax: * for j in range(ny): * pymin = ymin + j * dy # <<<<<<<<<<<<<< * pymax = pymin + dy * if pymax > bymin and pymin < bymax: */ __pyx_v_pymin = (__pyx_v_ymin + (__pyx_v_j * __pyx_v_dy)); /* "regions/_geometry/polygonal_overlap.pyx":82 * for j in range(ny): * pymin = ymin + j * dy * pymax = pymin + dy # <<<<<<<<<<<<<< * if pymax > bymin and pymin < bymax: * frac[j, i] = polygonal_overlap_single_subpixel(pxmin, pymin, */ __pyx_v_pymax = (__pyx_v_pymin + __pyx_v_dy); /* "regions/_geometry/polygonal_overlap.pyx":83 * pymin = ymin + j * dy * pymax = pymin + dy * if pymax > bymin and pymin < bymax: # <<<<<<<<<<<<<< * frac[j, i] = polygonal_overlap_single_subpixel(pxmin, pymin, * pxmax, pymax, */ __pyx_t_11 = ((__pyx_v_pymax > __pyx_v_bymin) != 0); if (__pyx_t_11) { } else { __pyx_t_6 = __pyx_t_11; goto __pyx_L12_bool_binop_done; } __pyx_t_11 = ((__pyx_v_pymin < __pyx_v_bymax) != 0); __pyx_t_6 = __pyx_t_11; __pyx_L12_bool_binop_done:; if (__pyx_t_6) { /* "regions/_geometry/polygonal_overlap.pyx":84 * pymax = pymin + dy * if pymax > bymin and pymin < bymax: * frac[j, i] = polygonal_overlap_single_subpixel(pxmin, pymin, # <<<<<<<<<<<<<< * pxmax, pymax, * vx, vy, subpixels) */ __pyx_t_15 = __pyx_v_j; __pyx_t_16 = __pyx_v_i; __pyx_t_17 = -1; if (unlikely(__pyx_t_15 >= (size_t)__pyx_pybuffernd_frac.diminfo[0].shape)) __pyx_t_17 = 0; if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_frac.diminfo[1].shape)) __pyx_t_17 = 1; if (unlikely(__pyx_t_17 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_17); __PYX_ERR(0, 84, __pyx_L1_error) } *__Pyx_BufPtrStrided2d(__pyx_t_7regions_9_geometry_17polygonal_overlap_DTYPE_t *, __pyx_pybuffernd_frac.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_frac.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_frac.diminfo[1].strides) = __pyx_f_7regions_9_geometry_17polygonal_overlap_polygonal_overlap_single_subpixel(__pyx_v_pxmin, __pyx_v_pymin, __pyx_v_pxmax, __pyx_v_pymax, ((PyArrayObject *)__pyx_v_vx), ((PyArrayObject *)__pyx_v_vy), __pyx_v_subpixels); /* "regions/_geometry/polygonal_overlap.pyx":83 * pymin = ymin + j * dy * pymax = pymin + dy * if pymax > bymin and pymin < bymax: # <<<<<<<<<<<<<< * frac[j, i] = polygonal_overlap_single_subpixel(pxmin, pymin, * pxmax, pymax, */ } } /* "regions/_geometry/polygonal_overlap.pyx":79 * pxmin = xmin + i * dx # lower end of pixel * pxmax = pxmin + dx # upper end of pixel * if pxmax > bxmin and pxmin < bxmax: # <<<<<<<<<<<<<< * for j in range(ny): * pymin = ymin + j * dy */ } } /* "regions/_geometry/polygonal_overlap.pyx":88 * vx, vy, subpixels) * * return frac # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_frac)); __pyx_r = ((PyObject *)__pyx_v_frac); goto __pyx_L0; /* "regions/_geometry/polygonal_overlap.pyx":21 * * * def polygonal_overlap_grid(double xmin, double xmax, double ymin, double ymax, # <<<<<<<<<<<<<< * int nx, int ny, * np.ndarray[DTYPE_t, ndim=1] vx, */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_frac.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vx.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vy.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("regions._geometry.polygonal_overlap.polygonal_overlap_grid", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_frac.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vx.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vy.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_frac); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/polygonal_overlap.pyx":91 * * * cdef double polygonal_overlap_single_subpixel(double x0, double y0, # <<<<<<<<<<<<<< * double x1, double y1, * np.ndarray[DTYPE_t, ndim=1] vx, */ static double __pyx_f_7regions_9_geometry_17polygonal_overlap_polygonal_overlap_single_subpixel(double __pyx_v_x0, double __pyx_v_y0, double __pyx_v_x1, double __pyx_v_y1, PyArrayObject *__pyx_v_vx, PyArrayObject *__pyx_v_vy, int __pyx_v_subpixels) { CYTHON_UNUSED unsigned int __pyx_v_i; CYTHON_UNUSED unsigned int __pyx_v_j; double __pyx_v_x; double __pyx_v_y; double __pyx_v_dx; double __pyx_v_dy; double __pyx_v_frac; __Pyx_LocalBuf_ND __pyx_pybuffernd_vx; __Pyx_Buffer __pyx_pybuffer_vx; __Pyx_LocalBuf_ND __pyx_pybuffernd_vy; __Pyx_Buffer __pyx_pybuffer_vy; double __pyx_r; __Pyx_RefNannyDeclarations double __pyx_t_1; int __pyx_t_2; int __pyx_t_3; unsigned int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; unsigned int __pyx_t_7; int __pyx_t_8; __Pyx_RefNannySetupContext("polygonal_overlap_single_subpixel", 0); __pyx_pybuffer_vx.pybuffer.buf = NULL; __pyx_pybuffer_vx.refcount = 0; __pyx_pybuffernd_vx.data = NULL; __pyx_pybuffernd_vx.rcbuffer = &__pyx_pybuffer_vx; __pyx_pybuffer_vy.pybuffer.buf = NULL; __pyx_pybuffer_vy.refcount = 0; __pyx_pybuffernd_vy.data = NULL; __pyx_pybuffernd_vy.rcbuffer = &__pyx_pybuffer_vy; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vx.rcbuffer->pybuffer, (PyObject*)__pyx_v_vx, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_17polygonal_overlap_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 91, __pyx_L1_error) } __pyx_pybuffernd_vx.diminfo[0].strides = __pyx_pybuffernd_vx.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vx.diminfo[0].shape = __pyx_pybuffernd_vx.rcbuffer->pybuffer.shape[0]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vy.rcbuffer->pybuffer, (PyObject*)__pyx_v_vy, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_17polygonal_overlap_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 91, __pyx_L1_error) } __pyx_pybuffernd_vy.diminfo[0].strides = __pyx_pybuffernd_vy.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vy.diminfo[0].shape = __pyx_pybuffernd_vy.rcbuffer->pybuffer.shape[0]; /* "regions/_geometry/polygonal_overlap.pyx":103 * cdef unsigned int i, j * cdef double x, y, dx, dy * cdef double frac = 0. # Accumulator. # <<<<<<<<<<<<<< * * dx = (x1 - x0) / subpixels */ __pyx_v_frac = 0.; /* "regions/_geometry/polygonal_overlap.pyx":105 * cdef double frac = 0. # Accumulator. * * dx = (x1 - x0) / subpixels # <<<<<<<<<<<<<< * dy = (y1 - y0) / subpixels * */ __pyx_t_1 = (__pyx_v_x1 - __pyx_v_x0); if (unlikely(__pyx_v_subpixels == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 105, __pyx_L1_error) } __pyx_v_dx = (__pyx_t_1 / ((double)__pyx_v_subpixels)); /* "regions/_geometry/polygonal_overlap.pyx":106 * * dx = (x1 - x0) / subpixels * dy = (y1 - y0) / subpixels # <<<<<<<<<<<<<< * * x = x0 - 0.5 * dx */ __pyx_t_1 = (__pyx_v_y1 - __pyx_v_y0); if (unlikely(__pyx_v_subpixels == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 106, __pyx_L1_error) } __pyx_v_dy = (__pyx_t_1 / ((double)__pyx_v_subpixels)); /* "regions/_geometry/polygonal_overlap.pyx":108 * dy = (y1 - y0) / subpixels * * x = x0 - 0.5 * dx # <<<<<<<<<<<<<< * for i in range(subpixels): * x += dx */ __pyx_v_x = (__pyx_v_x0 - (0.5 * __pyx_v_dx)); /* "regions/_geometry/polygonal_overlap.pyx":109 * * x = x0 - 0.5 * dx * for i in range(subpixels): # <<<<<<<<<<<<<< * x += dx * y = y0 - 0.5 * dy */ __pyx_t_2 = __pyx_v_subpixels; __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; /* "regions/_geometry/polygonal_overlap.pyx":110 * x = x0 - 0.5 * dx * for i in range(subpixels): * x += dx # <<<<<<<<<<<<<< * y = y0 - 0.5 * dy * for j in range(subpixels): */ __pyx_v_x = (__pyx_v_x + __pyx_v_dx); /* "regions/_geometry/polygonal_overlap.pyx":111 * for i in range(subpixels): * x += dx * y = y0 - 0.5 * dy # <<<<<<<<<<<<<< * for j in range(subpixels): * y += dy */ __pyx_v_y = (__pyx_v_y0 - (0.5 * __pyx_v_dy)); /* "regions/_geometry/polygonal_overlap.pyx":112 * x += dx * y = y0 - 0.5 * dy * for j in range(subpixels): # <<<<<<<<<<<<<< * y += dy * if point_in_polygon(x, y, vx, vy) == 1: */ __pyx_t_5 = __pyx_v_subpixels; __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_j = __pyx_t_7; /* "regions/_geometry/polygonal_overlap.pyx":113 * y = y0 - 0.5 * dy * for j in range(subpixels): * y += dy # <<<<<<<<<<<<<< * if point_in_polygon(x, y, vx, vy) == 1: * frac += 1. */ __pyx_v_y = (__pyx_v_y + __pyx_v_dy); /* "regions/_geometry/polygonal_overlap.pyx":114 * for j in range(subpixels): * y += dy * if point_in_polygon(x, y, vx, vy) == 1: # <<<<<<<<<<<<<< * frac += 1. * */ __pyx_t_8 = ((__pyx_f_7regions_9_geometry_6pnpoly_point_in_polygon(__pyx_v_x, __pyx_v_y, ((PyArrayObject *)__pyx_v_vx), ((PyArrayObject *)__pyx_v_vy)) == 1) != 0); if (__pyx_t_8) { /* "regions/_geometry/polygonal_overlap.pyx":115 * y += dy * if point_in_polygon(x, y, vx, vy) == 1: * frac += 1. # <<<<<<<<<<<<<< * * return frac / (subpixels * subpixels) */ __pyx_v_frac = (__pyx_v_frac + 1.); /* "regions/_geometry/polygonal_overlap.pyx":114 * for j in range(subpixels): * y += dy * if point_in_polygon(x, y, vx, vy) == 1: # <<<<<<<<<<<<<< * frac += 1. * */ } } } /* "regions/_geometry/polygonal_overlap.pyx":117 * frac += 1. * * return frac / (subpixels * subpixels) # <<<<<<<<<<<<<< */ __pyx_t_2 = (__pyx_v_subpixels * __pyx_v_subpixels); if (unlikely(__pyx_t_2 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 117, __pyx_L1_error) } __pyx_r = (__pyx_v_frac / ((double)__pyx_t_2)); goto __pyx_L0; /* "regions/_geometry/polygonal_overlap.pyx":91 * * * cdef double polygonal_overlap_single_subpixel(double x0, double y0, # <<<<<<<<<<<<<< * double x1, double y1, * np.ndarray[DTYPE_t, ndim=1] vx, */ /* function exit code */ __pyx_L1_error:; { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vx.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vy.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_WriteUnraisable("regions._geometry.polygonal_overlap.polygonal_overlap_single_subpixel", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vx.rcbuffer->pybuffer); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vy.rcbuffer->pybuffer); __pyx_L2:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< * # This implementation of getbuffer is geared towards Cython * # requirements, and does not yet fulfill the PEP. */ /* Python wrapper */ static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_v_i; int __pyx_v_ndim; int __pyx_v_endian_detector; int __pyx_v_little_endian; int __pyx_v_t; char *__pyx_v_f; PyArray_Descr *__pyx_v_descr = 0; int __pyx_v_offset; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyArray_Descr *__pyx_t_7; PyObject *__pyx_t_8 = NULL; char *__pyx_t_9; if (__pyx_v_info == NULL) { PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); return -1; } __Pyx_RefNannySetupContext("__getbuffer__", 0); __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 * * cdef int i, ndim * cdef int endian_detector = 1 # <<<<<<<<<<<<<< * cdef bint little_endian = ((&endian_detector)[0] != 0) * */ __pyx_v_endian_detector = 1; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 * cdef int i, ndim * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * * ndim = PyArray_NDIM(self) */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 * cdef bint little_endian = ((&endian_detector)[0] != 0) * * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) */ __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< * raise ValueError(u"ndarray is not C contiguous") * */ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 272, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L7_bool_binop_done; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< * raise ValueError(u"ndarray is not Fortran contiguous") * */ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L7_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 276, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 * raise ValueError(u"ndarray is not Fortran contiguous") * * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 * * info.buf = PyArray_DATA(self) * info.ndim = ndim # <<<<<<<<<<<<<< * if sizeof(npy_intp) != sizeof(Py_ssize_t): * # Allocate new buffer for strides and shape info. */ __pyx_v_info->ndim = __pyx_v_ndim; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. */ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< * info.shape = info.strides + ndim * for i in range(ndim): */ __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim # <<<<<<<<<<<<<< * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] */ __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim * for i in range(ndim): # <<<<<<<<<<<<<< * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] */ __pyx_t_4 = __pyx_v_ndim; __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286 * info.shape = info.strides + ndim * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< * info.shape[i] = PyArray_DIMS(self)[i] * else: */ (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287 * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< * else: * info.strides = PyArray_STRIDES(self) */ (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. */ goto __pyx_L9; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289 * info.shape[i] = PyArray_DIMS(self)[i] * else: * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL */ /*else*/ { __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 * else: * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) */ __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); } __pyx_L9:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL # <<<<<<<<<<<<<< * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) */ __pyx_v_info->suboffsets = NULL; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< * info.readonly = not PyArray_ISWRITEABLE(self) * */ __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< * * cdef int t */ __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296 * * cdef int t * cdef char* f = NULL # <<<<<<<<<<<<<< * cdef dtype descr = PyArray_DESCR(self) * cdef int offset */ __pyx_v_f = NULL; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297 * cdef int t * cdef char* f = NULL * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< * cdef int offset * */ __pyx_t_7 = PyArray_DESCR(__pyx_v_self); __pyx_t_3 = ((PyObject *)__pyx_t_7); __Pyx_INCREF(__pyx_t_3); __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300 * cdef int offset * * info.obj = self # <<<<<<<<<<<<<< * * if not PyDataType_HASFIELDS(descr): */ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or */ __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303 * * if not PyDataType_HASFIELDS(descr): * t = descr.type_num # <<<<<<<<<<<<<< * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): */ __pyx_t_4 = __pyx_v_descr->type_num; __pyx_v_t = __pyx_t_4; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); if (!__pyx_t_2) { goto __pyx_L15_next_or; } else { } __pyx_t_2 = (__pyx_v_little_endian != 0); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L14_bool_binop_done; } __pyx_L15_next_or:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305 * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" */ __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L14_bool_binop_done; } __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L14_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 306, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307 * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" */ switch (__pyx_v_t) { case NPY_BYTE: __pyx_v_f = ((char *)"b"); break; case NPY_UBYTE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308 * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" */ __pyx_v_f = ((char *)"B"); break; case NPY_SHORT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309 * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" */ __pyx_v_f = ((char *)"h"); break; case NPY_USHORT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310 * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" */ __pyx_v_f = ((char *)"H"); break; case NPY_INT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311 * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" */ __pyx_v_f = ((char *)"i"); break; case NPY_UINT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312 * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" */ __pyx_v_f = ((char *)"I"); break; case NPY_LONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313 * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" */ __pyx_v_f = ((char *)"l"); break; case NPY_ULONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314 * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" */ __pyx_v_f = ((char *)"L"); break; case NPY_LONGLONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315 * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" */ __pyx_v_f = ((char *)"q"); break; case NPY_ULONGLONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316 * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" */ __pyx_v_f = ((char *)"Q"); break; case NPY_FLOAT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317 * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" */ __pyx_v_f = ((char *)"f"); break; case NPY_DOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318 * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" */ __pyx_v_f = ((char *)"d"); break; case NPY_LONGDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319 * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" */ __pyx_v_f = ((char *)"g"); break; case NPY_CFLOAT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320 * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" */ __pyx_v_f = ((char *)"Zf"); break; case NPY_CDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321 * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" */ __pyx_v_f = ((char *)"Zd"); break; case NPY_CLONGDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322 * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f = "O" * else: */ __pyx_v_f = ((char *)"Zg"); break; case NPY_OBJECT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323 * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ __pyx_v_f = ((char *)"O"); break; default: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325 * elif t == NPY_OBJECT: f = "O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * info.format = f * return */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 325, __pyx_L1_error) break; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f # <<<<<<<<<<<<<< * return * else: */ __pyx_v_info->format = __pyx_v_f; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327 * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f * return # <<<<<<<<<<<<<< * else: * info.format = PyObject_Malloc(_buffer_format_string_len) */ __pyx_r = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329 * return * else: * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 */ /*else*/ { __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330 * else: * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< * offset = 0 * f = _util_dtypestring(descr, info.format + 1, */ (__pyx_v_info->format[0]) = '^'; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331 * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 # <<<<<<<<<<<<<< * f = _util_dtypestring(descr, info.format + 1, * info.format + _buffer_format_string_len, */ __pyx_v_offset = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332 * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< * info.format + _buffer_format_string_len, * &offset) */ __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error) __pyx_v_f = __pyx_t_9; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335 * info.format + _buffer_format_string_len, * &offset) * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< * * def __releasebuffer__(ndarray self, Py_buffer* info): */ (__pyx_v_f[0]) = '\x00'; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< * # This implementation of getbuffer is geared towards Cython * # requirements, and does not yet fulfill the PEP. */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; if (__pyx_v_info->obj != NULL) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } goto __pyx_L2; __pyx_L0:; if (__pyx_v_info->obj == Py_None) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_descr); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) */ /* Python wrapper */ static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__releasebuffer__", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339 * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) # <<<<<<<<<<<<<< * if sizeof(npy_intp) != sizeof(Py_ssize_t): * PyObject_Free(info.strides) */ PyObject_Free(__pyx_v_info->format); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * PyObject_Free(info.strides) * # info.shape was stored after info.strides in the same block */ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341 * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): * PyObject_Free(info.strides) # <<<<<<<<<<<<<< * # info.shape was stored after info.strides in the same block * */ PyObject_Free(__pyx_v_info->strides); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * PyObject_Free(info.strides) * # info.shape was stored after info.strides in the same block */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":825 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 828, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 831, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * * cdef inline tuple PyDataType_SHAPE(dtype d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< * else: * return () */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_empty_tuple); __pyx_r = __pyx_empty_tuple; goto __pyx_L0; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< * # Recursive utility function used in __getbuffer__ to get format * # string. The new location in the format string is returned. */ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { PyArray_Descr *__pyx_v_child = 0; int __pyx_v_endian_detector; int __pyx_v_little_endian; PyObject *__pyx_v_fields = 0; PyObject *__pyx_v_childname = NULL; PyObject *__pyx_v_new_offset = NULL; PyObject *__pyx_v_t = NULL; char *__pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; int __pyx_t_7; long __pyx_t_8; char *__pyx_t_9; __Pyx_RefNannySetupContext("_util_dtypestring", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847 * * cdef dtype child * cdef int endian_detector = 1 # <<<<<<<<<<<<<< * cdef bint little_endian = ((&endian_detector)[0] != 0) * cdef tuple fields */ __pyx_v_endian_detector = 1; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":848 * cdef dtype child * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * cdef tuple fields * */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< * fields = descr.fields[childname] * child, new_offset = fields */ if (unlikely(__pyx_v_descr->names == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(1, 851, __pyx_L1_error) } __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 851, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852 * * for childname in descr.names: * fields = descr.fields[childname] # <<<<<<<<<<<<<< * child, new_offset = fields * */ if (unlikely(__pyx_v_descr->fields == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 852, __pyx_L1_error) } __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":853 * for childname in descr.names: * fields = descr.fields[childname] * child, new_offset = fields # <<<<<<<<<<<<<< * * if (end - f) - (new_offset - offset[0]) < 15: */ if (likely(__pyx_v_fields != Py_None)) { PyObject* sequence = __pyx_v_fields; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(1, 853, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } else { __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 853, __pyx_L1_error) } if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); __pyx_t_4 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 856, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); if (!__pyx_t_7) { goto __pyx_L8_next_or; } else { } __pyx_t_7 = (__pyx_v_little_endian != 0); if (!__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_L8_next_or:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859 * * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< * raise ValueError(u"Non-native byte order not supported") * # One could encode it in the format string and have Cython */ __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); if (__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_6 = __pyx_t_7; __pyx_L7_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":860 * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * # One could encode it in the format string and have Cython * # complain instead, BUT: < and > in format strings also imply */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 860, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 860, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870 * * # Output padding bytes * while offset[0] < new_offset: # <<<<<<<<<<<<<< * f[0] = 120 # "x"; pad byte * f += 1 */ while (1) { __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_6) break; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871 * # Output padding bytes * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< * f += 1 * offset[0] += 1 */ (__pyx_v_f[0]) = 0x78; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872 * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte * f += 1 # <<<<<<<<<<<<<< * offset[0] += 1 * */ __pyx_v_f = (__pyx_v_f + 1); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":873 * f[0] = 120 # "x"; pad byte * f += 1 * offset[0] += 1 # <<<<<<<<<<<<<< * * offset[0] += child.itemsize */ __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":875 * offset[0] += 1 * * offset[0] += child.itemsize # <<<<<<<<<<<<<< * * if not PyDataType_HASFIELDS(child): */ __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< * t = child.type_num * if end - f < 5: */ __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); if (__pyx_t_6) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 * * if not PyDataType_HASFIELDS(child): * t = child.type_num # <<<<<<<<<<<<<< * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); __pyx_t_4 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short.") * */ __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 880, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short.") * */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883 * * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 98; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884 * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 66; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885 * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x68; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886 * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 72; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887 * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x69; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888 * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 73; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889 * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x6C; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890 * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 76; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891 * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x71; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892 * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 81; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893 * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x66; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894 * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x64; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895 * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x67; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896 * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x66; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897 * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x64; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898 * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x67; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":899 * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(__pyx_t_6)) { (__pyx_v_f[0]) = 79; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901 * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * f += 1 * else: */ /*else*/ { __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 901, __pyx_L1_error) } __pyx_L15:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":902 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * f += 1 # <<<<<<<<<<<<<< * else: * # Cython ignores struct boundary information ("T{...}"), */ __pyx_v_f = (__pyx_v_f + 1); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< * t = child.type_num * if end - f < 5: */ goto __pyx_L13; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906 * # Cython ignores struct boundary information ("T{...}"), * # so don't output it * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< * return f * */ /*else*/ { __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 906, __pyx_L1_error) __pyx_v_f = __pyx_t_9; } __pyx_L13:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< * fields = descr.fields[childname] * child, new_offset = fields */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":907 * # so don't output it * f = _util_dtypestring(child, f, end, offset) * return f # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_f; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< * # Recursive utility function used in __getbuffer__ to get format * # string. The new location in the format string is returned. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_child); __Pyx_XDECREF(__pyx_v_fields); __Pyx_XDECREF(__pyx_v_childname); __Pyx_XDECREF(__pyx_v_new_offset); __Pyx_XDECREF(__pyx_v_t); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< * PyArray_SetBaseObject(arr, base) * */ Py_INCREF(__pyx_v_base); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1024 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * * cdef inline object get_array_base(ndarray arr): */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< * if base is NULL: * return None */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< * return base * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1030 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< * * # Versions of the import_* functions which are more suitable for */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * _import_array() */ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_array", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036 * cdef inline int import_array() except -1: * try: * _import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1036, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 * try: * _import_array() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.multiarray failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1037, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1038, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1038, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * _import_array() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_umath", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1042, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1043, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1044, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1044, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_ufunc", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1048, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1049, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1050 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1050, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1050, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec_polygonal_overlap(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_polygonal_overlap}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "polygonal_overlap", 0, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_DTYPE, __pyx_k_DTYPE, sizeof(__pyx_k_DTYPE), 0, 0, 1, 1}, {&__pyx_kp_u_Exact_mode_has_not_been_implemen, __pyx_k_Exact_mode_has_not_been_implemen, sizeof(__pyx_k_Exact_mode_has_not_been_implemen), 0, 1, 0, 0}, {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, {&__pyx_n_s_bxmax, __pyx_k_bxmax, sizeof(__pyx_k_bxmax), 0, 0, 1, 1}, {&__pyx_n_s_bxmin, __pyx_k_bxmin, sizeof(__pyx_k_bxmin), 0, 0, 1, 1}, {&__pyx_n_s_bymax, __pyx_k_bymax, sizeof(__pyx_k_bymax), 0, 0, 1, 1}, {&__pyx_n_s_bymin, __pyx_k_bymin, sizeof(__pyx_k_bymin), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_d, __pyx_k_d, sizeof(__pyx_k_d), 0, 0, 1, 1}, {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, {&__pyx_n_s_dx, __pyx_k_dx, sizeof(__pyx_k_dx), 0, 0, 1, 1}, {&__pyx_n_s_dy, __pyx_k_dy, sizeof(__pyx_k_dy), 0, 0, 1, 1}, {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1}, {&__pyx_n_s_frac, __pyx_k_frac, sizeof(__pyx_k_frac), 0, 0, 1, 1}, {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1}, {&__pyx_n_s_min, __pyx_k_min, sizeof(__pyx_k_min), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, {&__pyx_n_s_nx, __pyx_k_nx, sizeof(__pyx_k_nx), 0, 0, 1, 1}, {&__pyx_n_s_ny, __pyx_k_ny, sizeof(__pyx_k_ny), 0, 0, 1, 1}, {&__pyx_n_s_pixel_radius, __pyx_k_pixel_radius, sizeof(__pyx_k_pixel_radius), 0, 0, 1, 1}, {&__pyx_n_s_polygonal_overlap_grid, __pyx_k_polygonal_overlap_grid, sizeof(__pyx_k_polygonal_overlap_grid), 0, 0, 1, 1}, {&__pyx_n_u_polygonal_overlap_grid, __pyx_k_polygonal_overlap_grid, sizeof(__pyx_k_polygonal_overlap_grid), 0, 1, 0, 1}, {&__pyx_n_s_pxcen, __pyx_k_pxcen, sizeof(__pyx_k_pxcen), 0, 0, 1, 1}, {&__pyx_n_s_pxmax, __pyx_k_pxmax, sizeof(__pyx_k_pxmax), 0, 0, 1, 1}, {&__pyx_n_s_pxmin, __pyx_k_pxmin, sizeof(__pyx_k_pxmin), 0, 0, 1, 1}, {&__pyx_n_s_pycen, __pyx_k_pycen, sizeof(__pyx_k_pycen), 0, 0, 1, 1}, {&__pyx_n_s_pymax, __pyx_k_pymax, sizeof(__pyx_k_pymax), 0, 0, 1, 1}, {&__pyx_n_s_pymin, __pyx_k_pymin, sizeof(__pyx_k_pymin), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_kp_s_regions__geometry_polygonal_over, __pyx_k_regions__geometry_polygonal_over, sizeof(__pyx_k_regions__geometry_polygonal_over), 0, 0, 1, 0}, {&__pyx_n_s_regions__geometry_polygonal_over_2, __pyx_k_regions__geometry_polygonal_over_2, sizeof(__pyx_k_regions__geometry_polygonal_over_2), 0, 0, 1, 1}, {&__pyx_n_s_subpixels, __pyx_k_subpixels, sizeof(__pyx_k_subpixels), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, {&__pyx_n_s_use_exact, __pyx_k_use_exact, sizeof(__pyx_k_use_exact), 0, 0, 1, 1}, {&__pyx_n_s_vx, __pyx_k_vx, sizeof(__pyx_k_vx), 0, 0, 1, 1}, {&__pyx_n_s_vy, __pyx_k_vy, sizeof(__pyx_k_vy), 0, 0, 1, 1}, {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, {&__pyx_n_s_xmax, __pyx_k_xmax, sizeof(__pyx_k_xmax), 0, 0, 1, 1}, {&__pyx_n_s_xmin, __pyx_k_xmin, sizeof(__pyx_k_xmin), 0, 0, 1, 1}, {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, {&__pyx_n_s_ymax, __pyx_k_ymax, sizeof(__pyx_k_ymax), 0, 0, 1, 1}, {&__pyx_n_s_ymin, __pyx_k_ymin, sizeof(__pyx_k_ymin), 0, 0, 1, 1}, {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 63, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 76, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error) __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 856, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1038, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "regions/_geometry/polygonal_overlap.pyx":63 * * if use_exact == 1: * raise NotImplementedError("Exact mode has not been implemented for " # <<<<<<<<<<<<<< * "polygonal apertures") * */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_Exact_mode_has_not_been_implemen); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 1038, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 1044, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "regions/_geometry/polygonal_overlap.pyx":21 * * * def polygonal_overlap_grid(double xmin, double xmax, double ymin, double ymax, # <<<<<<<<<<<<<< * int nx, int ny, * np.ndarray[DTYPE_t, ndim=1] vx, */ __pyx_tuple__9 = PyTuple_Pack(29, __pyx_n_s_xmin, __pyx_n_s_xmax, __pyx_n_s_ymin, __pyx_n_s_ymax, __pyx_n_s_nx, __pyx_n_s_ny, __pyx_n_s_vx, __pyx_n_s_vy, __pyx_n_s_use_exact, __pyx_n_s_subpixels, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_dx, __pyx_n_s_dy, __pyx_n_s_d, __pyx_n_s_pixel_radius, __pyx_n_s_bxmin, __pyx_n_s_bxmax, __pyx_n_s_bymin, __pyx_n_s_bymax, __pyx_n_s_pxmin, __pyx_n_s_pxcen, __pyx_n_s_pxmax, __pyx_n_s_pymin, __pyx_n_s_pycen, __pyx_n_s_pymax, __pyx_n_s_frac); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(10, 0, 29, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_regions__geometry_polygonal_over, __pyx_n_s_polygonal_overlap_grid, 21, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 sizeof(PyTypeObject), #else sizeof(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error) __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error) __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 918, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __pyx_t_1 = PyImport_ImportModule("regions._geometry.pnpoly"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ImportFunction(__pyx_t_1, "point_in_polygon", (void (**)(void))&__pyx_f_7regions_9_geometry_6pnpoly_point_in_polygon, "int (double, double, PyArrayObject *, PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) Py_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } #if PY_MAJOR_VERSION < 3 #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC void #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #else #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyObject * #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC initpolygonal_overlap(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC initpolygonal_overlap(void) #else __Pyx_PyMODINIT_FUNC PyInit_polygonal_overlap(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_polygonal_overlap(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec_polygonal_overlap(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module 'polygonal_overlap' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_polygonal_overlap(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("polygonal_overlap", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_regions___geometry__polygonal_overlap) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "regions._geometry.polygonal_overlap")) { if (unlikely(PyDict_SetItemString(modules, "regions._geometry.polygonal_overlap", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); (void)__Pyx_modinit_type_init_code(); if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error; (void)__Pyx_modinit_variable_import_code(); if (unlikely(__Pyx_modinit_function_import_code() != 0)) goto __pyx_L1_error; /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "regions/_geometry/polygonal_overlap.pyx":6 * unicode_literals) * * import numpy as np # <<<<<<<<<<<<<< * cimport numpy as np * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/polygonal_overlap.pyx":10 * * * __all__ = ['polygonal_overlap_grid'] # <<<<<<<<<<<<<< * * */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_u_polygonal_overlap_grid); __Pyx_GIVEREF(__pyx_n_u_polygonal_overlap_grid); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_u_polygonal_overlap_grid); if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_t_1) < 0) __PYX_ERR(0, 10, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/polygonal_overlap.pyx":13 * * * DTYPE = np.float64 # <<<<<<<<<<<<<< * ctypedef np.float64_t DTYPE_t * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE, __pyx_t_2) < 0) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/polygonal_overlap.pyx":18 * from .pnpoly cimport point_in_polygon * * __all__ = ['polygonal_overlap_grid'] # <<<<<<<<<<<<<< * * */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_u_polygonal_overlap_grid); __Pyx_GIVEREF(__pyx_n_u_polygonal_overlap_grid); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_u_polygonal_overlap_grid); if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_t_2) < 0) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/polygonal_overlap.pyx":21 * * * def polygonal_overlap_grid(double xmin, double xmax, double ymin, double ymax, # <<<<<<<<<<<<<< * int nx, int ny, * np.ndarray[DTYPE_t, ndim=1] vx, */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7regions_9_geometry_17polygonal_overlap_1polygonal_overlap_grid, NULL, __pyx_n_s_regions__geometry_polygonal_over_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_polygonal_overlap_grid, __pyx_t_2) < 0) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/polygonal_overlap.pyx":1 * # Licensed under a 3-clause BSD style license - see LICENSE.rst # <<<<<<<<<<<<<< * # cython: language_level=3 * from __future__ import (absolute_import, division, print_function, */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init regions._geometry.polygonal_overlap", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init regions._geometry.polygonal_overlap"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* ArgTypeTest */ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } else if (exact) { #if PY_MAJOR_VERSION == 2 if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; #endif } else { if (likely(__Pyx_TypeCheck(obj, type))) return 1; } PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", name, type->tp_name, Py_TYPE(obj)->tp_name); return 0; } /* IsLittleEndian */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) { union { uint32_t u32; uint8_t u8[4]; } S; S.u32 = 0x01020304; return S.u8[0] == 4; } /* BufferFormatCheck */ static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type) { stack[0].field = &ctx->root; stack[0].parent_offset = 0; ctx->root.type = type; ctx->root.name = "buffer dtype"; ctx->root.offset = 0; ctx->head = stack; ctx->head->field = &ctx->root; ctx->fmt_offset = 0; ctx->head->parent_offset = 0; ctx->new_packmode = '@'; ctx->enc_packmode = '@'; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->is_complex = 0; ctx->is_valid_array = 0; ctx->struct_alignment = 0; while (type->typegroup == 'S') { ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = 0; type = type->fields->type; } } static int __Pyx_BufFmt_ParseNumber(const char** ts) { int count; const char* t = *ts; if (*t < '0' || *t > '9') { return -1; } else { count = *t++ - '0'; while (*t >= '0' && *t <= '9') { count *= 10; count += *t++ - '0'; } } *ts = t; return count; } static int __Pyx_BufFmt_ExpectNumber(const char **ts) { int number = __Pyx_BufFmt_ParseNumber(ts); if (number == -1) PyErr_Format(PyExc_ValueError,\ "Does not understand character buffer dtype format string ('%c')", **ts); return number; } static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { PyErr_Format(PyExc_ValueError, "Unexpected format string character: '%c'", ch); } static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { switch (ch) { case 'c': return "'char'"; case 'b': return "'signed char'"; case 'B': return "'unsigned char'"; case 'h': return "'short'"; case 'H': return "'unsigned short'"; case 'i': return "'int'"; case 'I': return "'unsigned int'"; case 'l': return "'long'"; case 'L': return "'unsigned long'"; case 'q': return "'long long'"; case 'Q': return "'unsigned long long'"; case 'f': return (is_complex ? "'complex float'" : "'float'"); case 'd': return (is_complex ? "'complex double'" : "'double'"); case 'g': return (is_complex ? "'complex long double'" : "'long double'"); case 'T': return "a struct"; case 'O': return "Python object"; case 'P': return "a pointer"; case 's': case 'p': return "a string"; case 0: return "end"; default: return "unparseable format string"; } } static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return 2; case 'i': case 'I': case 'l': case 'L': return 4; case 'q': case 'Q': return 8; case 'f': return (is_complex ? 8 : 4); case 'd': return (is_complex ? 16 : 8); case 'g': { PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); return 0; } case 'O': case 'P': return sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { switch (ch) { case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(short); case 'i': case 'I': return sizeof(int); case 'l': case 'L': return sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(float) * (is_complex ? 2 : 1); case 'd': return sizeof(double) * (is_complex ? 2 : 1); case 'g': return sizeof(long double) * (is_complex ? 2 : 1); case 'O': case 'P': return sizeof(void*); default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } typedef struct { char c; short x; } __Pyx_st_short; typedef struct { char c; int x; } __Pyx_st_int; typedef struct { char c; long x; } __Pyx_st_long; typedef struct { char c; float x; } __Pyx_st_float; typedef struct { char c; double x; } __Pyx_st_double; typedef struct { char c; long double x; } __Pyx_st_longdouble; typedef struct { char c; void *x; } __Pyx_st_void_p; #ifdef HAVE_LONG_LONG typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_st_float) - sizeof(float); case 'd': return sizeof(__Pyx_st_double) - sizeof(double); case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } /* These are for computing the padding at the end of the struct to align on the first member of the struct. This will probably the same as above, but we don't have any guarantees. */ typedef struct { short x; char c; } __Pyx_pad_short; typedef struct { int x; char c; } __Pyx_pad_int; typedef struct { long x; char c; } __Pyx_pad_long; typedef struct { float x; char c; } __Pyx_pad_float; typedef struct { double x; char c; } __Pyx_pad_double; typedef struct { long double x; char c; } __Pyx_pad_longdouble; typedef struct { void *x; char c; } __Pyx_pad_void_p; #ifdef HAVE_LONG_LONG typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { switch (ch) { case 'c': return 'H'; case 'b': case 'h': case 'i': case 'l': case 'q': case 's': case 'p': return 'I'; case 'B': case 'H': case 'I': case 'L': case 'Q': return 'U'; case 'f': case 'd': case 'g': return (is_complex ? 'C' : 'R'); case 'O': return 'O'; case 'P': return 'P'; default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { if (ctx->head == NULL || ctx->head->field == &ctx->root) { const char* expected; const char* quote; if (ctx->head == NULL) { expected = "end"; quote = ""; } else { expected = ctx->head->field->type->name; quote = "'"; } PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected %s%s%s but got %s", quote, expected, quote, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); } else { __Pyx_StructField* field = ctx->head->field; __Pyx_StructField* parent = (ctx->head - 1)->field; PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), parent->type->name, field->name); } } static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { char group; size_t size, offset, arraysize = 1; if (ctx->enc_type == 0) return 0; if (ctx->head->field->type->arraysize[0]) { int i, ndim = 0; if (ctx->enc_type == 's' || ctx->enc_type == 'p') { ctx->is_valid_array = ctx->head->field->type->ndim == 1; ndim = 1; if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %zu", ctx->head->field->type->arraysize[0], ctx->enc_count); return -1; } } if (!ctx->is_valid_array) { PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", ctx->head->field->type->ndim, ndim); return -1; } for (i = 0; i < ctx->head->field->type->ndim; i++) { arraysize *= ctx->head->field->type->arraysize[i]; } ctx->is_valid_array = 0; ctx->enc_count = 1; } group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); do { __Pyx_StructField* field = ctx->head->field; __Pyx_TypeInfo* type = field->type; if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); } else { size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); } if (ctx->enc_packmode == '@') { size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); size_t align_mod_offset; if (align_at == 0) return -1; align_mod_offset = ctx->fmt_offset % align_at; if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; if (ctx->struct_alignment == 0) ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, ctx->is_complex); } if (type->size != size || type->typegroup != group) { if (type->typegroup == 'C' && type->fields != NULL) { size_t parent_offset = ctx->head->parent_offset + field->offset; ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = parent_offset; continue; } if ((type->typegroup == 'H' || group == 'H') && type->size == size) { } else { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } } offset = ctx->head->parent_offset + field->offset; if (ctx->fmt_offset != offset) { PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); return -1; } ctx->fmt_offset += size; if (arraysize) ctx->fmt_offset += (arraysize - 1) * size; --ctx->enc_count; while (1) { if (field == &ctx->root) { ctx->head = NULL; if (ctx->enc_count != 0) { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } break; } ctx->head->field = ++field; if (field->type == NULL) { --ctx->head; field = ctx->head->field; continue; } else if (field->type->typegroup == 'S') { size_t parent_offset = ctx->head->parent_offset + field->offset; if (field->type->fields->type == NULL) continue; field = field->type->fields; ++ctx->head; ctx->head->field = field; ctx->head->parent_offset = parent_offset; break; } else { break; } } } while (ctx->enc_count); ctx->enc_type = 0; ctx->is_complex = 0; return 0; } static PyObject * __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { const char *ts = *tsp; int i = 0, number; int ndim = ctx->head->field->type->ndim; ; ++ts; if (ctx->new_count != 1) { PyErr_SetString(PyExc_ValueError, "Cannot handle repeated arrays in format string"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; while (*ts && *ts != ')') { switch (*ts) { case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; default: break; } number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) return PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %d", ctx->head->field->type->arraysize[i], number); if (*ts != ',' && *ts != ')') return PyErr_Format(PyExc_ValueError, "Expected a comma in format string, got '%c'", *ts); if (*ts == ',') ts++; i++; } if (i != ndim) return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", ctx->head->field->type->ndim, i); if (!*ts) { PyErr_SetString(PyExc_ValueError, "Unexpected end of format string, expected ')'"); return NULL; } ctx->is_valid_array = 1; ctx->new_count = 1; *tsp = ++ts; return Py_None; } static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { int got_Z = 0; while (1) { switch(*ts) { case 0: if (ctx->enc_type != 0 && ctx->head == NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; if (ctx->head != NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } return ts; case ' ': case '\r': case '\n': ++ts; break; case '<': if (!__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '>': case '!': if (__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '=': case '@': case '^': ctx->new_packmode = *ts++; break; case 'T': { const char* ts_after_sub; size_t i, struct_count = ctx->new_count; size_t struct_alignment = ctx->struct_alignment; ctx->new_count = 1; ++ts; if (*ts != '{') { PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; ctx->enc_count = 0; ctx->struct_alignment = 0; ++ts; ts_after_sub = ts; for (i = 0; i != struct_count; ++i) { ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); if (!ts_after_sub) return NULL; } ts = ts_after_sub; if (struct_alignment) ctx->struct_alignment = struct_alignment; } break; case '}': { size_t alignment = ctx->struct_alignment; ++ts; if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; if (alignment && ctx->fmt_offset % alignment) { ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); } } return ts; case 'x': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->fmt_offset += ctx->new_count; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->enc_packmode = ctx->new_packmode; ++ts; break; case 'Z': got_Z = 1; ++ts; if (*ts != 'f' && *ts != 'd' && *ts != 'g') { __Pyx_BufFmt_RaiseUnexpectedChar('Z'); return NULL; } CYTHON_FALLTHROUGH; case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': case 'l': case 'L': case 'q': case 'Q': case 'f': case 'd': case 'g': case 'O': case 'p': if (ctx->enc_type == *ts && got_Z == ctx->is_complex && ctx->enc_packmode == ctx->new_packmode) { ctx->enc_count += ctx->new_count; ctx->new_count = 1; got_Z = 0; ++ts; break; } CYTHON_FALLTHROUGH; case 's': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_count = ctx->new_count; ctx->enc_packmode = ctx->new_packmode; ctx->enc_type = *ts; ctx->is_complex = got_Z; ++ts; ctx->new_count = 1; got_Z = 0; break; case ':': ++ts; while(*ts != ':') ++ts; ++ts; break; case '(': if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; break; default: { int number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; ctx->new_count = (size_t)number; } } } } /* BufferGetAndValidate */ static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { if (unlikely(info->buf == NULL)) return; if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; __Pyx_ReleaseBuffer(info); } static void __Pyx_ZeroBuffer(Py_buffer* buf) { buf->buf = NULL; buf->obj = NULL; buf->strides = __Pyx_zeros; buf->shape = __Pyx_zeros; buf->suboffsets = __Pyx_minusones; } static int __Pyx__GetBufferAndValidate( Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack) { buf->buf = NULL; if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { __Pyx_ZeroBuffer(buf); return -1; } if (unlikely(buf->ndim != nd)) { PyErr_Format(PyExc_ValueError, "Buffer has wrong number of dimensions (expected %d, got %d)", nd, buf->ndim); goto fail; } if (!cast) { __Pyx_BufFmt_Context ctx; __Pyx_BufFmt_Init(&ctx, stack, dtype); if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; } if (unlikely((size_t)buf->itemsize != dtype->size)) { PyErr_Format(PyExc_ValueError, "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", buf->itemsize, (buf->itemsize > 1) ? "s" : "", dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); goto fail; } if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; return 0; fail:; __Pyx_SafeReleaseBuffer(buf); return -1; } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallNoArg */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, NULL, 0); } #endif #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) #else if (likely(PyCFunction_Check(func))) #endif { if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* BufferIndexError */ static void __Pyx_RaiseBufferIndexError(int axis) { PyErr_Format(PyExc_IndexError, "Out of bounds on buffer access (axis %d)", axis); } /* WriteUnraisableException */ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback, CYTHON_UNUSED int nogil) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_PyThreadState_declare #ifdef WITH_THREAD PyGILState_STATE state; if (nogil) state = PyGILState_Ensure(); #ifdef _MSC_VER else state = (PyGILState_STATE)-1; #endif #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } #ifdef WITH_THREAD if (nogil) PyGILState_Release(state); #endif } /* DictGetItem */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); if (unlikely(!value)) { if (!PyErr_Occurred()) { if (unlikely(PyTuple_Check(key))) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) { PyErr_SetObject(PyExc_KeyError, args); Py_DECREF(args); } } else { PyErr_SetObject(PyExc_KeyError, key); } } return NULL; } Py_INCREF(value); return value; } #endif /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* RaiseNoneIterError */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; #ifdef Py_LIMITED_API PyObject *py_basicsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #ifndef Py_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if ((size_t)basicsize < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(result); return NULL; } #endif /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.')) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); return -1; } static void __Pyx_ReleaseBuffer(Py_buffer *view) { PyObject *obj = view->obj; if (!obj) return; if (PyObject_CheckBuffer(obj)) { PyBuffer_Release(view); return; } if ((0)) {} else if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); view->obj = NULL; Py_DECREF(obj); } #endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return ::std::complex< float >(x, y); } #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return x + y*(__pyx_t_float_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { __pyx_t_float_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabsf(b.real) >= fabsf(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { float r = b.imag / b.real; float s = (float)(1.0) / (b.real + b.imag * r); return __pyx_t_float_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { float r = b.real / b.imag; float s = (float)(1.0) / (b.imag + b.real * r); return __pyx_t_float_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else { float denom = b.real * b.real + b.imag * b.imag; return __pyx_t_float_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrtf(z.real*z.real + z.imag*z.imag); #else return hypotf(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; float r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { float denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(a, a); case 3: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, a); case 4: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = powf(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2f(0.0, -1.0); } } else { r = __Pyx_c_abs_float(a); theta = atan2f(a.imag, a.real); } lnr = logf(r); z_r = expf(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cosf(z_theta); z.imag = z_r * sinf(z_theta); return z; } #endif #endif /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return ::std::complex< double >(x, y); } #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return x + y*(__pyx_t_double_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { __pyx_t_double_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabs(b.real) >= fabs(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { double r = b.imag / b.real; double s = (double)(1.0) / (b.real + b.imag * r); return __pyx_t_double_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { double r = b.real / b.imag; double s = (double)(1.0) / (b.imag + b.real * r); return __pyx_t_double_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else { double denom = b.real * b.real + b.imag * b.imag; return __pyx_t_double_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrt(z.real*z.real + z.imag*z.imag); #else return hypot(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; double r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { double denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(a, a); case 3: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, a); case 4: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = pow(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2(0.0, -1.0); } } else { r = __Pyx_c_abs_double(a); theta = atan2(a.imag, a.real); } lnr = log(r); z_r = exp(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cos(z_theta); z.imag = z_r * sin(z_theta); return z; } #endif #endif /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(enum NPY_TYPES) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(enum NPY_TYPES) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntFromPy */ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (unsigned int) 1), const_zero = (unsigned int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(unsigned int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (unsigned int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned int) 0; case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0]) case 2: if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) { return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; case 3: if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) { return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; case 4: if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT) { return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (unsigned int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(unsigned int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned int) 0; case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, +digits[0]) case -2: if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 2: if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case -3: if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 3: if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case -4: if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 4: if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; } #endif if (sizeof(unsigned int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else unsigned int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (unsigned int) -1; } } else { unsigned int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (unsigned int) -1; val = __Pyx_PyInt_As_unsigned_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned int"); return (unsigned int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned int"); return (unsigned int) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i= 0x02070000 if (!PyCapsule_IsValid(cobj, sig)) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj)); goto bad; } tmp.p = PyCapsule_GetPointer(cobj, sig); #else {const char *desc, *s1, *s2; desc = (const char *)PyCObject_GetDesc(cobj); if (!desc) goto bad; s1 = desc; s2 = sig; while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } if (*s1 != *s2) { PyErr_Format(PyExc_TypeError, "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", PyModule_GetName(module), funcname, sig, desc); goto bad; } tmp.p = PyCObject_AsVoidPtr(cobj);} #endif *f = tmp.fp; if (!(*f)) goto bad; Py_DECREF(d); return 0; bad: Py_XDECREF(d); return -1; } #endif /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ regions-0.4/regions/_geometry/polygonal_overlap.pyx0000644000076600000240000000722513501414013023020 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst # cython: language_level=3 from __future__ import (absolute_import, division, print_function, unicode_literals) import numpy as np cimport numpy as np __all__ = ['polygonal_overlap_grid'] DTYPE = np.float64 ctypedef np.float64_t DTYPE_t from .pnpoly cimport point_in_polygon __all__ = ['polygonal_overlap_grid'] def polygonal_overlap_grid(double xmin, double xmax, double ymin, double ymax, int nx, int ny, np.ndarray[DTYPE_t, ndim=1] vx, np.ndarray[DTYPE_t, ndim=1] vy, int use_exact, int subpixels): """ polygonal_overlap_grid(xmin, xmax, ymin, ymax, nx, ny, r, use_exact, subpixels) Area of overlap between a polygon and a pixel grid. Parameters ---------- xmin, xmax, ymin, ymax : float Extent of the grid in the x and y direction. nx, ny : int Grid dimensions. vx, vy : `numpy.ndarray` The vertices of the polygon use_exact : 0 or 1 If ``1`` calculates exact overlap, if ``0`` uses ``subpixel`` number of subpixels to calculate the overlap. subpixels : int Each pixel resampled by this factor in each dimension, thus each pixel is divided into ``subpixels ** 2`` subpixels. Returns ------- frac : `~numpy.ndarray` (float) 2-d array of shape (ny, nx) giving the fraction of the overlap. """ cdef unsigned int i, j cdef double x, y, dx, dy, d, pixel_radius cdef double bxmin, bxmax, bymin, bymax cdef double pxmin, pxcen, pxmax, pymin, pycen, pymax # Define output array cdef np.ndarray[DTYPE_t, ndim=2] frac = np.zeros([ny, nx], dtype=DTYPE) if use_exact == 1: raise NotImplementedError("Exact mode has not been implemented for " "polygonal apertures") # Find the width of each element in x and y dx = (xmax - xmin) / nx dy = (ymax - ymin) / ny # Define bounding box bxmin = vx.min() bxmax = vx.max() bymin = vy.min() bymax = vy.max() for i in range(nx): pxmin = xmin + i * dx # lower end of pixel pxmax = pxmin + dx # upper end of pixel if pxmax > bxmin and pxmin < bxmax: for j in range(ny): pymin = ymin + j * dy pymax = pymin + dy if pymax > bymin and pymin < bymax: frac[j, i] = polygonal_overlap_single_subpixel(pxmin, pymin, pxmax, pymax, vx, vy, subpixels) return frac cdef double polygonal_overlap_single_subpixel(double x0, double y0, double x1, double y1, np.ndarray[DTYPE_t, ndim=1] vx, np.ndarray[DTYPE_t, ndim=1] vy, int subpixels): """ Return the fraction of overlap between a polygon and a single pixel with given extent, using a sub-pixel sampling method. """ cdef unsigned int i, j cdef double x, y, dx, dy cdef double frac = 0. # Accumulator. dx = (x1 - x0) / subpixels dy = (y1 - y0) / subpixels x = x0 - 0.5 * dx for i in range(subpixels): x += dx y = y0 - 0.5 * dy for j in range(subpixels): y += dy if point_in_polygon(x, y, vx, vy) == 1: frac += 1. return frac / (subpixels * subpixels) regions-0.4/regions/_geometry/rectangular_overlap.c0000644000076600000240000130263613501657423022750 0ustar deilstaff00000000000000/* Generated by Cython 0.29.6 */ #define PY_SSIZE_T_CLEAN #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_6" #define CYTHON_HEX_VERSION 0x001D06F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #ifndef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #define PyObject_Unicode PyObject_Str #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_ERR(f_index, lineno, Ln_error) \ { \ __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__regions___geometry__rectangular_overlap #define __PYX_HAVE_API__regions___geometry__rectangular_overlap /* Early includes */ #include #include #include "numpy/arrayobject.h" #include "numpy/ufuncobject.h" #include "math.h" #include "pythread.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; /* Header.proto */ #if !defined(CYTHON_CCOMPLEX) #if defined(__cplusplus) #define CYTHON_CCOMPLEX 1 #elif defined(_Complex_I) #define CYTHON_CCOMPLEX 1 #else #define CYTHON_CCOMPLEX 0 #endif #endif #if CYTHON_CCOMPLEX #ifdef __cplusplus #include #else #include #endif #endif #if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) #undef _Complex_I #define _Complex_I 1.0fj #endif static const char *__pyx_f[] = { "regions/_geometry/rectangular_overlap.pyx", "__init__.pxd", "type.pxd", "bool.pxd", "complex.pxd", }; /* BufferFormatStructs.proto */ #define IS_UNSIGNED(type) (((type) -1) > 0) struct __Pyx_StructField_; #define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) typedef struct { const char* name; struct __Pyx_StructField_* fields; size_t size; size_t arraysize[8]; int ndim; char typegroup; char is_unsigned; int flags; } __Pyx_TypeInfo; typedef struct __Pyx_StructField_ { __Pyx_TypeInfo* type; const char* name; size_t offset; } __Pyx_StructField; typedef struct { __Pyx_StructField* field; size_t parent_offset; } __Pyx_BufFmt_StackElem; typedef struct { __Pyx_StructField root; __Pyx_BufFmt_StackElem* head; size_t fmt_offset; size_t new_count, enc_count; size_t struct_alignment; int is_complex; char enc_type; char new_packmode; char enc_packmode; char is_valid_array; } __Pyx_BufFmt_Context; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t */ typedef npy_int8 __pyx_t_5numpy_int8_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t */ typedef npy_int16 __pyx_t_5numpy_int16_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":778 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< * ctypedef npy_int64 int64_t * #ctypedef npy_int96 int96_t */ typedef npy_int32 __pyx_t_5numpy_int32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< * #ctypedef npy_int96 int96_t * #ctypedef npy_int128 int128_t */ typedef npy_int64 __pyx_t_5numpy_int64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":784 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< * ctypedef npy_uint64 uint64_t * #ctypedef npy_uint96 uint96_t */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":786 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< * #ctypedef npy_uint96 uint96_t * #ctypedef npy_uint128 uint128_t */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< * ctypedef npy_float64 float64_t * #ctypedef npy_float80 float80_t */ typedef npy_float32 __pyx_t_5numpy_float32_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< * #ctypedef npy_float80 float80_t * #ctypedef npy_float128 float128_t */ typedef npy_float64 __pyx_t_5numpy_float64_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":800 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t */ typedef npy_long __pyx_t_5numpy_int_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< * ctypedef npy_longlong longlong_t * */ typedef npy_longlong __pyx_t_5numpy_long_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< * * ctypedef npy_ulong uint_t */ typedef npy_longlong __pyx_t_5numpy_longlong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":804 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t */ typedef npy_ulong __pyx_t_5numpy_uint_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":805 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< * ctypedef npy_ulonglong ulonglong_t * */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":806 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< * * ctypedef npy_intp intp_t */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":808 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< * ctypedef npy_uintp uintp_t * */ typedef npy_intp __pyx_t_5numpy_intp_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":809 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< * * ctypedef npy_double float_t */ typedef npy_uintp __pyx_t_5numpy_uintp_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":811 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t */ typedef npy_double __pyx_t_5numpy_float_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":812 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< * ctypedef npy_longdouble longdouble_t * */ typedef npy_double __pyx_t_5numpy_double_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cfloat cfloat_t */ typedef npy_longdouble __pyx_t_5numpy_longdouble_t; /* "regions/_geometry/rectangular_overlap.pyx":24 * * DTYPE = np.float64 * ctypedef np.float64_t DTYPE_t # <<<<<<<<<<<<<< * * cimport cython */ typedef __pyx_t_5numpy_float64_t __pyx_t_7regions_9_geometry_19rectangular_overlap_DTYPE_t; /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< float > __pyx_t_float_complex; #else typedef float _Complex __pyx_t_float_complex; #endif #else typedef struct { float real, imag; } __pyx_t_float_complex; #endif static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus typedef ::std::complex< double > __pyx_t_double_complex; #else typedef double _Complex __pyx_t_double_complex; #endif #else typedef struct { double real, imag; } __pyx_t_double_complex; #endif static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); /*--- Type declarations ---*/ /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< * ctypedef npy_clongdouble clongdouble_t * */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":817 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< * * ctypedef npy_cdouble complex_t */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":819 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew1(a): */ typedef npy_cdouble __pyx_t_5numpy_complex_t; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* IsLittleEndian.proto */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); /* BufferFormatCheck.proto */ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type); /* BufferGetAndValidate.proto */ #define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ ((obj == Py_None || obj == NULL) ?\ (__Pyx_ZeroBuffer(buf), 0) :\ __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); static void __Pyx_ZeroBuffer(Py_buffer* buf); static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* BufferIndexError.proto */ static void __Pyx_RaiseBufferIndexError(int axis); #define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1) /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto #define __PYX_HAVE_RT_ImportType_proto enum __Pyx_ImportType_CheckSize { __Pyx_ImportType_CheckSize_Error = 0, __Pyx_ImportType_CheckSize_Warn = 1, __Pyx_ImportType_CheckSize_Ignore = 2 }; static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* BufferStructDeclare.proto */ typedef struct { Py_ssize_t shape, strides, suboffsets; } __Pyx_Buf_DimInfo; typedef struct { size_t refcount; Py_buffer pybuffer; } __Pyx_Buffer; typedef struct { __Pyx_Buffer *rcbuffer; char *data; __Pyx_Buf_DimInfo diminfo[8]; } __Pyx_LocalBuf_ND; #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); static void __Pyx_ReleaseBuffer(Py_buffer *view); #else #define __Pyx_GetBuffer PyObject_GetBuffer #define __Pyx_ReleaseBuffer PyBuffer_Release #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus #define __Pyx_CREAL(z) ((z).real()) #define __Pyx_CIMAG(z) ((z).imag()) #else #define __Pyx_CREAL(z) (__real__(z)) #define __Pyx_CIMAG(z) (__imag__(z)) #endif #else #define __Pyx_CREAL(z) ((z).real) #define __Pyx_CIMAG(z) ((z).imag) #endif #if defined(__cplusplus) && CYTHON_CCOMPLEX\ && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) #define __Pyx_SET_CREAL(z,x) ((z).real(x)) #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) #else #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_float(a, b) ((a)==(b)) #define __Pyx_c_sum_float(a, b) ((a)+(b)) #define __Pyx_c_diff_float(a, b) ((a)-(b)) #define __Pyx_c_prod_float(a, b) ((a)*(b)) #define __Pyx_c_quot_float(a, b) ((a)/(b)) #define __Pyx_c_neg_float(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_float(z) ((z)==(float)0) #define __Pyx_c_conj_float(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_float(z) (::std::abs(z)) #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_float(z) ((z)==0) #define __Pyx_c_conj_float(z) (conjf(z)) #if 1 #define __Pyx_c_abs_float(z) (cabsf(z)) #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); #endif #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX #define __Pyx_c_eq_double(a, b) ((a)==(b)) #define __Pyx_c_sum_double(a, b) ((a)+(b)) #define __Pyx_c_diff_double(a, b) ((a)-(b)) #define __Pyx_c_prod_double(a, b) ((a)*(b)) #define __Pyx_c_quot_double(a, b) ((a)/(b)) #define __Pyx_c_neg_double(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_double(z) ((z)==(double)0) #define __Pyx_c_conj_double(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_double(z) (::std::abs(z)) #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_double(z) ((z)==0) #define __Pyx_c_conj_double(z) (conj(z)) #if 1 #define __Pyx_c_abs_double(z) (cabs(z)) #define __Pyx_c_pow_double(a, b) (cpow(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); #endif #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'cpython.buffer' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdio' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.type' */ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; /* Module declarations from 'cpython.version' */ /* Module declarations from 'cpython.exc' */ /* Module declarations from 'cpython.module' */ /* Module declarations from 'cpython.mem' */ /* Module declarations from 'cpython.tuple' */ /* Module declarations from 'cpython.list' */ /* Module declarations from 'cpython.sequence' */ /* Module declarations from 'cpython.mapping' */ /* Module declarations from 'cpython.iterator' */ /* Module declarations from 'cpython.number' */ /* Module declarations from 'cpython.int' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.bool' */ static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; /* Module declarations from 'cpython.long' */ /* Module declarations from 'cpython.float' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.complex' */ static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; /* Module declarations from 'cpython.string' */ /* Module declarations from 'cpython.unicode' */ /* Module declarations from 'cpython.dict' */ /* Module declarations from 'cpython.instance' */ /* Module declarations from 'cpython.function' */ /* Module declarations from 'cpython.method' */ /* Module declarations from 'cpython.weakref' */ /* Module declarations from 'cpython.getargs' */ /* Module declarations from 'cpython.pythread' */ /* Module declarations from 'cpython.pystate' */ /* Module declarations from 'cpython.cobject' */ /* Module declarations from 'cpython.oldbuffer' */ /* Module declarations from 'cpython.set' */ /* Module declarations from 'cpython.bytes' */ /* Module declarations from 'cpython.pycapsule' */ /* Module declarations from 'cpython' */ /* Module declarations from 'cpython.object' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'numpy' */ /* Module declarations from 'numpy' */ static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ /* Module declarations from 'cython' */ /* Module declarations from 'regions._geometry.rectangular_overlap' */ static double __pyx_f_7regions_9_geometry_19rectangular_overlap_rectangular_overlap_single_subpixel(double, double, double, double, double, double, double, int); /*proto*/ static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_19rectangular_overlap_DTYPE_t = { "DTYPE_t", NULL, sizeof(__pyx_t_7regions_9_geometry_19rectangular_overlap_DTYPE_t), { 0 }, 0, 'R', 0, 0 }; #define __Pyx_MODULE_NAME "regions._geometry.rectangular_overlap" extern int __pyx_module_is_main_regions___geometry__rectangular_overlap; int __pyx_module_is_main_regions___geometry__rectangular_overlap = 0; /* Implementation of 'regions._geometry.rectangular_overlap' */ static PyObject *__pyx_builtin_NotImplementedError; static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_ImportError; static const char __pyx_k_i[] = "i"; static const char __pyx_k_j[] = "j"; static const char __pyx_k_x[] = "x"; static const char __pyx_k_y[] = "y"; static const char __pyx_k_dx[] = "dx"; static const char __pyx_k_dy[] = "dy"; static const char __pyx_k_np[] = "np"; static const char __pyx_k_nx[] = "nx"; static const char __pyx_k_ny[] = "ny"; static const char __pyx_k_all[] = "__all__"; static const char __pyx_k_frac[] = "frac"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_xmax[] = "xmax"; static const char __pyx_k_xmin[] = "xmin"; static const char __pyx_k_ymax[] = "ymax"; static const char __pyx_k_ymin[] = "ymin"; static const char __pyx_k_DTYPE[] = "DTYPE"; static const char __pyx_k_dtype[] = "dtype"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_pxmax[] = "pxmax"; static const char __pyx_k_pxmin[] = "pxmin"; static const char __pyx_k_pymax[] = "pymax"; static const char __pyx_k_pymin[] = "pymin"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_theta[] = "theta"; static const char __pyx_k_width[] = "width"; static const char __pyx_k_zeros[] = "zeros"; static const char __pyx_k_height[] = "height"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_float64[] = "float64"; static const char __pyx_k_subpixels[] = "subpixels"; static const char __pyx_k_use_exact[] = "use_exact"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_RuntimeError[] = "RuntimeError"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_NotImplementedError[] = "NotImplementedError"; static const char __pyx_k_rectangular_overlap_grid[] = "rectangular_overlap_grid"; static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; static const char __pyx_k_Exact_mode_has_not_been_implemen[] = "Exact mode has not been implemented for rectangular apertures"; static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; static const char __pyx_k_regions__geometry_rectangular_ov[] = "regions/_geometry/rectangular_overlap.pyx"; static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; static const char __pyx_k_regions__geometry_rectangular_ov_2[] = "regions._geometry.rectangular_overlap"; static PyObject *__pyx_n_s_DTYPE; static PyObject *__pyx_kp_u_Exact_mode_has_not_been_implemen; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; static PyObject *__pyx_n_s_NotImplementedError; static PyObject *__pyx_n_s_RuntimeError; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_all; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_dx; static PyObject *__pyx_n_s_dy; static PyObject *__pyx_n_s_float64; static PyObject *__pyx_n_s_frac; static PyObject *__pyx_n_s_height; static PyObject *__pyx_n_s_i; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_j; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_name; static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; static PyObject *__pyx_n_s_nx; static PyObject *__pyx_n_s_ny; static PyObject *__pyx_n_s_pxmax; static PyObject *__pyx_n_s_pxmin; static PyObject *__pyx_n_s_pymax; static PyObject *__pyx_n_s_pymin; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_rectangular_overlap_grid; static PyObject *__pyx_n_u_rectangular_overlap_grid; static PyObject *__pyx_kp_s_regions__geometry_rectangular_ov; static PyObject *__pyx_n_s_regions__geometry_rectangular_ov_2; static PyObject *__pyx_n_s_subpixels; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_theta; static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; static PyObject *__pyx_n_s_use_exact; static PyObject *__pyx_n_s_width; static PyObject *__pyx_n_s_x; static PyObject *__pyx_n_s_xmax; static PyObject *__pyx_n_s_xmin; static PyObject *__pyx_n_s_y; static PyObject *__pyx_n_s_ymax; static PyObject *__pyx_n_s_ymin; static PyObject *__pyx_n_s_zeros; static PyObject *__pyx_pf_7regions_9_geometry_19rectangular_overlap_rectangular_overlap_grid(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_xmin, double __pyx_v_xmax, double __pyx_v_ymin, double __pyx_v_ymax, int __pyx_v_nx, int __pyx_v_ny, double __pyx_v_width, double __pyx_v_height, double __pyx_v_theta, int __pyx_v_use_exact, int __pyx_v_subpixels); /* proto */ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; static PyObject *__pyx_codeobj__10; /* Late includes */ /* "regions/_geometry/rectangular_overlap.pyx":29 * * * def rectangular_overlap_grid(double xmin, double xmax, double ymin, # <<<<<<<<<<<<<< * double ymax, int nx, int ny, double width, * double height, double theta, int use_exact, */ /* Python wrapper */ static PyObject *__pyx_pw_7regions_9_geometry_19rectangular_overlap_1rectangular_overlap_grid(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7regions_9_geometry_19rectangular_overlap_rectangular_overlap_grid[] = "\n rectangular_overlap_grid(xmin, xmax, ymin, ymax, nx, ny, width, height,\n use_exact, subpixels)\n\n Area of overlap between a rectangle and a pixel grid. The rectangle is\n centered on the origin.\n\n Parameters\n ----------\n xmin, xmax, ymin, ymax : float\n Extent of the grid in the x and y direction.\n nx, ny : int\n Grid dimensions.\n width : float\n The width of the rectangle\n height : float\n The height of the rectangle\n theta : float\n The position angle of the rectangle in radians (counterclockwise).\n use_exact : 0 or 1\n If set to 1, calculates the exact overlap, while if set to 0, uses a\n subpixel sampling method with ``subpixel`` subpixels in each direction.\n subpixels : int\n If ``use_exact`` is 0, each pixel is resampled by this factor in each\n dimension. Thus, each pixel is divided into ``subpixels ** 2``\n subpixels.\n\n Returns\n -------\n frac : `~numpy.ndarray`\n 2-d array giving the fraction of the overlap.\n "; static PyMethodDef __pyx_mdef_7regions_9_geometry_19rectangular_overlap_1rectangular_overlap_grid = {"rectangular_overlap_grid", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7regions_9_geometry_19rectangular_overlap_1rectangular_overlap_grid, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7regions_9_geometry_19rectangular_overlap_rectangular_overlap_grid}; static PyObject *__pyx_pw_7regions_9_geometry_19rectangular_overlap_1rectangular_overlap_grid(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { double __pyx_v_xmin; double __pyx_v_xmax; double __pyx_v_ymin; double __pyx_v_ymax; int __pyx_v_nx; int __pyx_v_ny; double __pyx_v_width; double __pyx_v_height; double __pyx_v_theta; int __pyx_v_use_exact; int __pyx_v_subpixels; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("rectangular_overlap_grid (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_xmin,&__pyx_n_s_xmax,&__pyx_n_s_ymin,&__pyx_n_s_ymax,&__pyx_n_s_nx,&__pyx_n_s_ny,&__pyx_n_s_width,&__pyx_n_s_height,&__pyx_n_s_theta,&__pyx_n_s_use_exact,&__pyx_n_s_subpixels,0}; PyObject* values[11] = {0,0,0,0,0,0,0,0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); CYTHON_FALLTHROUGH; case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); CYTHON_FALLTHROUGH; case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); CYTHON_FALLTHROUGH; case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); CYTHON_FALLTHROUGH; case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); CYTHON_FALLTHROUGH; case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xmin)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xmax)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("rectangular_overlap_grid", 1, 11, 11, 1); __PYX_ERR(0, 29, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ymin)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("rectangular_overlap_grid", 1, 11, 11, 2); __PYX_ERR(0, 29, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ymax)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("rectangular_overlap_grid", 1, 11, 11, 3); __PYX_ERR(0, 29, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nx)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("rectangular_overlap_grid", 1, 11, 11, 4); __PYX_ERR(0, 29, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ny)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("rectangular_overlap_grid", 1, 11, 11, 5); __PYX_ERR(0, 29, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 6: if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_width)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("rectangular_overlap_grid", 1, 11, 11, 6); __PYX_ERR(0, 29, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 7: if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_height)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("rectangular_overlap_grid", 1, 11, 11, 7); __PYX_ERR(0, 29, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 8: if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_theta)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("rectangular_overlap_grid", 1, 11, 11, 8); __PYX_ERR(0, 29, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 9: if (likely((values[9] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_use_exact)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("rectangular_overlap_grid", 1, 11, 11, 9); __PYX_ERR(0, 29, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 10: if (likely((values[10] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_subpixels)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("rectangular_overlap_grid", 1, 11, 11, 10); __PYX_ERR(0, 29, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "rectangular_overlap_grid") < 0)) __PYX_ERR(0, 29, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 11) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); values[4] = PyTuple_GET_ITEM(__pyx_args, 4); values[5] = PyTuple_GET_ITEM(__pyx_args, 5); values[6] = PyTuple_GET_ITEM(__pyx_args, 6); values[7] = PyTuple_GET_ITEM(__pyx_args, 7); values[8] = PyTuple_GET_ITEM(__pyx_args, 8); values[9] = PyTuple_GET_ITEM(__pyx_args, 9); values[10] = PyTuple_GET_ITEM(__pyx_args, 10); } __pyx_v_xmin = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_xmin == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 29, __pyx_L3_error) __pyx_v_xmax = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_xmax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 29, __pyx_L3_error) __pyx_v_ymin = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_ymin == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 29, __pyx_L3_error) __pyx_v_ymax = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_ymax == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 30, __pyx_L3_error) __pyx_v_nx = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_nx == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 30, __pyx_L3_error) __pyx_v_ny = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_ny == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 30, __pyx_L3_error) __pyx_v_width = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_width == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 30, __pyx_L3_error) __pyx_v_height = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_height == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 31, __pyx_L3_error) __pyx_v_theta = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_theta == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 31, __pyx_L3_error) __pyx_v_use_exact = __Pyx_PyInt_As_int(values[9]); if (unlikely((__pyx_v_use_exact == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 31, __pyx_L3_error) __pyx_v_subpixels = __Pyx_PyInt_As_int(values[10]); if (unlikely((__pyx_v_subpixels == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 32, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("rectangular_overlap_grid", 1, 11, 11, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 29, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("regions._geometry.rectangular_overlap.rectangular_overlap_grid", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7regions_9_geometry_19rectangular_overlap_rectangular_overlap_grid(__pyx_self, __pyx_v_xmin, __pyx_v_xmax, __pyx_v_ymin, __pyx_v_ymax, __pyx_v_nx, __pyx_v_ny, __pyx_v_width, __pyx_v_height, __pyx_v_theta, __pyx_v_use_exact, __pyx_v_subpixels); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7regions_9_geometry_19rectangular_overlap_rectangular_overlap_grid(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_xmin, double __pyx_v_xmax, double __pyx_v_ymin, double __pyx_v_ymax, int __pyx_v_nx, int __pyx_v_ny, double __pyx_v_width, double __pyx_v_height, double __pyx_v_theta, int __pyx_v_use_exact, int __pyx_v_subpixels) { unsigned int __pyx_v_i; unsigned int __pyx_v_j; double __pyx_v_dx; double __pyx_v_dy; double __pyx_v_pxmin; double __pyx_v_pxmax; double __pyx_v_pymin; double __pyx_v_pymax; PyArrayObject *__pyx_v_frac = 0; __Pyx_LocalBuf_ND __pyx_pybuffernd_frac; __Pyx_Buffer __pyx_pybuffer_frac; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyArrayObject *__pyx_t_5 = NULL; int __pyx_t_6; double __pyx_t_7; int __pyx_t_8; int __pyx_t_9; unsigned int __pyx_t_10; int __pyx_t_11; int __pyx_t_12; unsigned int __pyx_t_13; size_t __pyx_t_14; size_t __pyx_t_15; int __pyx_t_16; __Pyx_RefNannySetupContext("rectangular_overlap_grid", 0); __pyx_pybuffer_frac.pybuffer.buf = NULL; __pyx_pybuffer_frac.refcount = 0; __pyx_pybuffernd_frac.data = NULL; __pyx_pybuffernd_frac.rcbuffer = &__pyx_pybuffer_frac; /* "regions/_geometry/rectangular_overlap.pyx":71 * * # Define output array * cdef np.ndarray[DTYPE_t, ndim=2] frac = np.zeros([ny, nx], dtype=DTYPE) # <<<<<<<<<<<<<< * * if use_exact == 1: */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_ny); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_nx); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_3); PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 71, __pyx_L1_error) __pyx_t_5 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_frac.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_7regions_9_geometry_19rectangular_overlap_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) { __pyx_v_frac = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_frac.rcbuffer->pybuffer.buf = NULL; __PYX_ERR(0, 71, __pyx_L1_error) } else {__pyx_pybuffernd_frac.diminfo[0].strides = __pyx_pybuffernd_frac.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_frac.diminfo[0].shape = __pyx_pybuffernd_frac.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_frac.diminfo[1].strides = __pyx_pybuffernd_frac.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_frac.diminfo[1].shape = __pyx_pybuffernd_frac.rcbuffer->pybuffer.shape[1]; } } __pyx_t_5 = 0; __pyx_v_frac = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/rectangular_overlap.pyx":73 * cdef np.ndarray[DTYPE_t, ndim=2] frac = np.zeros([ny, nx], dtype=DTYPE) * * if use_exact == 1: # <<<<<<<<<<<<<< * raise NotImplementedError("Exact mode has not been implemented for " * "rectangular apertures") */ __pyx_t_6 = ((__pyx_v_use_exact == 1) != 0); if (unlikely(__pyx_t_6)) { /* "regions/_geometry/rectangular_overlap.pyx":74 * * if use_exact == 1: * raise NotImplementedError("Exact mode has not been implemented for " # <<<<<<<<<<<<<< * "rectangular apertures") * */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 74, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 74, __pyx_L1_error) /* "regions/_geometry/rectangular_overlap.pyx":73 * cdef np.ndarray[DTYPE_t, ndim=2] frac = np.zeros([ny, nx], dtype=DTYPE) * * if use_exact == 1: # <<<<<<<<<<<<<< * raise NotImplementedError("Exact mode has not been implemented for " * "rectangular apertures") */ } /* "regions/_geometry/rectangular_overlap.pyx":78 * * # Find the width of each element in x and y * dx = (xmax - xmin) / nx # <<<<<<<<<<<<<< * dy = (ymax - ymin) / ny * */ __pyx_t_7 = (__pyx_v_xmax - __pyx_v_xmin); if (unlikely(__pyx_v_nx == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 78, __pyx_L1_error) } __pyx_v_dx = (__pyx_t_7 / ((double)__pyx_v_nx)); /* "regions/_geometry/rectangular_overlap.pyx":79 * # Find the width of each element in x and y * dx = (xmax - xmin) / nx * dy = (ymax - ymin) / ny # <<<<<<<<<<<<<< * * # TODO: can implement a bounding box here for efficiency (as for the */ __pyx_t_7 = (__pyx_v_ymax - __pyx_v_ymin); if (unlikely(__pyx_v_ny == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 79, __pyx_L1_error) } __pyx_v_dy = (__pyx_t_7 / ((double)__pyx_v_ny)); /* "regions/_geometry/rectangular_overlap.pyx":84 * # circular and elliptical aperture photometry) * * for i in range(nx): # <<<<<<<<<<<<<< * pxmin = xmin + i * dx # lower end of pixel * pxmax = pxmin + dx # upper end of pixel */ __pyx_t_8 = __pyx_v_nx; __pyx_t_9 = __pyx_t_8; for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) { __pyx_v_i = __pyx_t_10; /* "regions/_geometry/rectangular_overlap.pyx":85 * * for i in range(nx): * pxmin = xmin + i * dx # lower end of pixel # <<<<<<<<<<<<<< * pxmax = pxmin + dx # upper end of pixel * for j in range(ny): */ __pyx_v_pxmin = (__pyx_v_xmin + (__pyx_v_i * __pyx_v_dx)); /* "regions/_geometry/rectangular_overlap.pyx":86 * for i in range(nx): * pxmin = xmin + i * dx # lower end of pixel * pxmax = pxmin + dx # upper end of pixel # <<<<<<<<<<<<<< * for j in range(ny): * pymin = ymin + j * dy */ __pyx_v_pxmax = (__pyx_v_pxmin + __pyx_v_dx); /* "regions/_geometry/rectangular_overlap.pyx":87 * pxmin = xmin + i * dx # lower end of pixel * pxmax = pxmin + dx # upper end of pixel * for j in range(ny): # <<<<<<<<<<<<<< * pymin = ymin + j * dy * pymax = pymin + dy */ __pyx_t_11 = __pyx_v_ny; __pyx_t_12 = __pyx_t_11; for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { __pyx_v_j = __pyx_t_13; /* "regions/_geometry/rectangular_overlap.pyx":88 * pxmax = pxmin + dx # upper end of pixel * for j in range(ny): * pymin = ymin + j * dy # <<<<<<<<<<<<<< * pymax = pymin + dy * frac[j, i] = rectangular_overlap_single_subpixel( */ __pyx_v_pymin = (__pyx_v_ymin + (__pyx_v_j * __pyx_v_dy)); /* "regions/_geometry/rectangular_overlap.pyx":89 * for j in range(ny): * pymin = ymin + j * dy * pymax = pymin + dy # <<<<<<<<<<<<<< * frac[j, i] = rectangular_overlap_single_subpixel( * pxmin, pymin, pxmax, pymax, width, height, theta, */ __pyx_v_pymax = (__pyx_v_pymin + __pyx_v_dy); /* "regions/_geometry/rectangular_overlap.pyx":90 * pymin = ymin + j * dy * pymax = pymin + dy * frac[j, i] = rectangular_overlap_single_subpixel( # <<<<<<<<<<<<<< * pxmin, pymin, pxmax, pymax, width, height, theta, * subpixels) */ __pyx_t_14 = __pyx_v_j; __pyx_t_15 = __pyx_v_i; __pyx_t_16 = -1; if (unlikely(__pyx_t_14 >= (size_t)__pyx_pybuffernd_frac.diminfo[0].shape)) __pyx_t_16 = 0; if (unlikely(__pyx_t_15 >= (size_t)__pyx_pybuffernd_frac.diminfo[1].shape)) __pyx_t_16 = 1; if (unlikely(__pyx_t_16 != -1)) { __Pyx_RaiseBufferIndexError(__pyx_t_16); __PYX_ERR(0, 90, __pyx_L1_error) } *__Pyx_BufPtrStrided2d(__pyx_t_7regions_9_geometry_19rectangular_overlap_DTYPE_t *, __pyx_pybuffernd_frac.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_frac.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_frac.diminfo[1].strides) = __pyx_f_7regions_9_geometry_19rectangular_overlap_rectangular_overlap_single_subpixel(__pyx_v_pxmin, __pyx_v_pymin, __pyx_v_pxmax, __pyx_v_pymax, __pyx_v_width, __pyx_v_height, __pyx_v_theta, __pyx_v_subpixels); } } /* "regions/_geometry/rectangular_overlap.pyx":94 * subpixels) * * return frac # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_frac)); __pyx_r = ((PyObject *)__pyx_v_frac); goto __pyx_L0; /* "regions/_geometry/rectangular_overlap.pyx":29 * * * def rectangular_overlap_grid(double xmin, double xmax, double ymin, # <<<<<<<<<<<<<< * double ymax, int nx, int ny, double width, * double height, double theta, int use_exact, */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_frac.rcbuffer->pybuffer); __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} __Pyx_AddTraceback("regions._geometry.rectangular_overlap.rectangular_overlap_grid", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; goto __pyx_L2; __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_frac.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_frac); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "regions/_geometry/rectangular_overlap.pyx":97 * * * cdef double rectangular_overlap_single_subpixel(double x0, double y0, # <<<<<<<<<<<<<< * double x1, double y1, * double width, double height, */ static double __pyx_f_7regions_9_geometry_19rectangular_overlap_rectangular_overlap_single_subpixel(double __pyx_v_x0, double __pyx_v_y0, double __pyx_v_x1, double __pyx_v_y1, double __pyx_v_width, double __pyx_v_height, double __pyx_v_theta, int __pyx_v_subpixels) { CYTHON_UNUSED unsigned int __pyx_v_i; CYTHON_UNUSED unsigned int __pyx_v_j; double __pyx_v_x; double __pyx_v_y; double __pyx_v_frac; double __pyx_v_cos_theta; double __pyx_v_sin_theta; double __pyx_v_half_width; double __pyx_v_half_height; double __pyx_v_dx; double __pyx_v_dy; double __pyx_v_x_tr; double __pyx_v_y_tr; double __pyx_r; __Pyx_RefNannyDeclarations double __pyx_t_1; int __pyx_t_2; int __pyx_t_3; unsigned int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; unsigned int __pyx_t_7; int __pyx_t_8; int __pyx_t_9; __Pyx_RefNannySetupContext("rectangular_overlap_single_subpixel", 0); /* "regions/_geometry/rectangular_overlap.pyx":108 * cdef unsigned int i, j * cdef double x, y * cdef double frac = 0. # Accumulator. # <<<<<<<<<<<<<< * cdef double cos_theta = cos(theta) * cdef double sin_theta = sin(theta) */ __pyx_v_frac = 0.; /* "regions/_geometry/rectangular_overlap.pyx":109 * cdef double x, y * cdef double frac = 0. # Accumulator. * cdef double cos_theta = cos(theta) # <<<<<<<<<<<<<< * cdef double sin_theta = sin(theta) * cdef double half_width, half_height */ __pyx_v_cos_theta = cos(__pyx_v_theta); /* "regions/_geometry/rectangular_overlap.pyx":110 * cdef double frac = 0. # Accumulator. * cdef double cos_theta = cos(theta) * cdef double sin_theta = sin(theta) # <<<<<<<<<<<<<< * cdef double half_width, half_height * */ __pyx_v_sin_theta = sin(__pyx_v_theta); /* "regions/_geometry/rectangular_overlap.pyx":113 * cdef double half_width, half_height * * half_width = width / 2. # <<<<<<<<<<<<<< * half_height = height / 2. * */ __pyx_v_half_width = (__pyx_v_width / 2.); /* "regions/_geometry/rectangular_overlap.pyx":114 * * half_width = width / 2. * half_height = height / 2. # <<<<<<<<<<<<<< * * dx = (x1 - x0) / subpixels */ __pyx_v_half_height = (__pyx_v_height / 2.); /* "regions/_geometry/rectangular_overlap.pyx":116 * half_height = height / 2. * * dx = (x1 - x0) / subpixels # <<<<<<<<<<<<<< * dy = (y1 - y0) / subpixels * */ __pyx_t_1 = (__pyx_v_x1 - __pyx_v_x0); if (unlikely(__pyx_v_subpixels == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 116, __pyx_L1_error) } __pyx_v_dx = (__pyx_t_1 / ((double)__pyx_v_subpixels)); /* "regions/_geometry/rectangular_overlap.pyx":117 * * dx = (x1 - x0) / subpixels * dy = (y1 - y0) / subpixels # <<<<<<<<<<<<<< * * x = x0 - 0.5 * dx */ __pyx_t_1 = (__pyx_v_y1 - __pyx_v_y0); if (unlikely(__pyx_v_subpixels == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 117, __pyx_L1_error) } __pyx_v_dy = (__pyx_t_1 / ((double)__pyx_v_subpixels)); /* "regions/_geometry/rectangular_overlap.pyx":119 * dy = (y1 - y0) / subpixels * * x = x0 - 0.5 * dx # <<<<<<<<<<<<<< * for i in range(subpixels): * x += dx */ __pyx_v_x = (__pyx_v_x0 - (0.5 * __pyx_v_dx)); /* "regions/_geometry/rectangular_overlap.pyx":120 * * x = x0 - 0.5 * dx * for i in range(subpixels): # <<<<<<<<<<<<<< * x += dx * y = y0 - 0.5 * dy */ __pyx_t_2 = __pyx_v_subpixels; __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; /* "regions/_geometry/rectangular_overlap.pyx":121 * x = x0 - 0.5 * dx * for i in range(subpixels): * x += dx # <<<<<<<<<<<<<< * y = y0 - 0.5 * dy * for j in range(subpixels): */ __pyx_v_x = (__pyx_v_x + __pyx_v_dx); /* "regions/_geometry/rectangular_overlap.pyx":122 * for i in range(subpixels): * x += dx * y = y0 - 0.5 * dy # <<<<<<<<<<<<<< * for j in range(subpixels): * y += dy */ __pyx_v_y = (__pyx_v_y0 - (0.5 * __pyx_v_dy)); /* "regions/_geometry/rectangular_overlap.pyx":123 * x += dx * y = y0 - 0.5 * dy * for j in range(subpixels): # <<<<<<<<<<<<<< * y += dy * */ __pyx_t_5 = __pyx_v_subpixels; __pyx_t_6 = __pyx_t_5; for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { __pyx_v_j = __pyx_t_7; /* "regions/_geometry/rectangular_overlap.pyx":124 * y = y0 - 0.5 * dy * for j in range(subpixels): * y += dy # <<<<<<<<<<<<<< * * # Transform into frame of rotated rectangle */ __pyx_v_y = (__pyx_v_y + __pyx_v_dy); /* "regions/_geometry/rectangular_overlap.pyx":127 * * # Transform into frame of rotated rectangle * x_tr = y * sin_theta + x * cos_theta # <<<<<<<<<<<<<< * y_tr = y * cos_theta - x * sin_theta * */ __pyx_v_x_tr = ((__pyx_v_y * __pyx_v_sin_theta) + (__pyx_v_x * __pyx_v_cos_theta)); /* "regions/_geometry/rectangular_overlap.pyx":128 * # Transform into frame of rotated rectangle * x_tr = y * sin_theta + x * cos_theta * y_tr = y * cos_theta - x * sin_theta # <<<<<<<<<<<<<< * * if fabs(x_tr) < half_width and fabs(y_tr) < half_height: */ __pyx_v_y_tr = ((__pyx_v_y * __pyx_v_cos_theta) - (__pyx_v_x * __pyx_v_sin_theta)); /* "regions/_geometry/rectangular_overlap.pyx":130 * y_tr = y * cos_theta - x * sin_theta * * if fabs(x_tr) < half_width and fabs(y_tr) < half_height: # <<<<<<<<<<<<<< * frac += 1. * */ __pyx_t_9 = ((fabs(__pyx_v_x_tr) < __pyx_v_half_width) != 0); if (__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; goto __pyx_L8_bool_binop_done; } __pyx_t_9 = ((fabs(__pyx_v_y_tr) < __pyx_v_half_height) != 0); __pyx_t_8 = __pyx_t_9; __pyx_L8_bool_binop_done:; if (__pyx_t_8) { /* "regions/_geometry/rectangular_overlap.pyx":131 * * if fabs(x_tr) < half_width and fabs(y_tr) < half_height: * frac += 1. # <<<<<<<<<<<<<< * * return frac / (subpixels * subpixels) */ __pyx_v_frac = (__pyx_v_frac + 1.); /* "regions/_geometry/rectangular_overlap.pyx":130 * y_tr = y * cos_theta - x * sin_theta * * if fabs(x_tr) < half_width and fabs(y_tr) < half_height: # <<<<<<<<<<<<<< * frac += 1. * */ } } } /* "regions/_geometry/rectangular_overlap.pyx":133 * frac += 1. * * return frac / (subpixels * subpixels) # <<<<<<<<<<<<<< */ __pyx_t_2 = (__pyx_v_subpixels * __pyx_v_subpixels); if (unlikely(__pyx_t_2 == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "float division"); __PYX_ERR(0, 133, __pyx_L1_error) } __pyx_r = (__pyx_v_frac / ((double)__pyx_t_2)); goto __pyx_L0; /* "regions/_geometry/rectangular_overlap.pyx":97 * * * cdef double rectangular_overlap_single_subpixel(double x0, double y0, # <<<<<<<<<<<<<< * double x1, double y1, * double width, double height, */ /* function exit code */ __pyx_L1_error:; __Pyx_WriteUnraisable("regions._geometry.rectangular_overlap.rectangular_overlap_single_subpixel", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< * # This implementation of getbuffer is geared towards Cython * # requirements, and does not yet fulfill the PEP. */ /* Python wrapper */ static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_v_i; int __pyx_v_ndim; int __pyx_v_endian_detector; int __pyx_v_little_endian; int __pyx_v_t; char *__pyx_v_f; PyArray_Descr *__pyx_v_descr = 0; int __pyx_v_offset; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyArray_Descr *__pyx_t_7; PyObject *__pyx_t_8 = NULL; char *__pyx_t_9; if (__pyx_v_info == NULL) { PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); return -1; } __Pyx_RefNannySetupContext("__getbuffer__", 0); __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 * * cdef int i, ndim * cdef int endian_detector = 1 # <<<<<<<<<<<<<< * cdef bint little_endian = ((&endian_detector)[0] != 0) * */ __pyx_v_endian_detector = 1; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 * cdef int i, ndim * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * * ndim = PyArray_NDIM(self) */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 * cdef bint little_endian = ((&endian_detector)[0] != 0) * * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) */ __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< * raise ValueError(u"ndarray is not C contiguous") * */ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 272, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 * ndim = PyArray_NDIM(self) * * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L7_bool_binop_done; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< * raise ValueError(u"ndarray is not Fortran contiguous") * */ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L7_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 276, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 * raise ValueError(u"ndarray is not C contiguous") * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 * raise ValueError(u"ndarray is not Fortran contiguous") * * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 * * info.buf = PyArray_DATA(self) * info.ndim = ndim # <<<<<<<<<<<<<< * if sizeof(npy_intp) != sizeof(Py_ssize_t): * # Allocate new buffer for strides and shape info. */ __pyx_v_info->ndim = __pyx_v_ndim; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. */ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< * info.shape = info.strides + ndim * for i in range(ndim): */ __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 * # This is allocated as one block, strides first. * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim # <<<<<<<<<<<<<< * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] */ __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) * info.shape = info.strides + ndim * for i in range(ndim): # <<<<<<<<<<<<<< * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] */ __pyx_t_4 = __pyx_v_ndim; __pyx_t_5 = __pyx_t_4; for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":286 * info.shape = info.strides + ndim * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< * info.shape[i] = PyArray_DIMS(self)[i] * else: */ (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":287 * for i in range(ndim): * info.strides[i] = PyArray_STRIDES(self)[i] * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< * else: * info.strides = PyArray_STRIDES(self) */ (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 * info.buf = PyArray_DATA(self) * info.ndim = ndim * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * # Allocate new buffer for strides and shape info. * # This is allocated as one block, strides first. */ goto __pyx_L9; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":289 * info.shape[i] = PyArray_DIMS(self)[i] * else: * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL */ /*else*/ { __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 * else: * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) */ __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); } __pyx_L9:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 * info.strides = PyArray_STRIDES(self) * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL # <<<<<<<<<<<<<< * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) */ __pyx_v_info->suboffsets = NULL; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 * info.shape = PyArray_DIMS(self) * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< * info.readonly = not PyArray_ISWRITEABLE(self) * */ __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 * info.suboffsets = NULL * info.itemsize = PyArray_ITEMSIZE(self) * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< * * cdef int t */ __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":296 * * cdef int t * cdef char* f = NULL # <<<<<<<<<<<<<< * cdef dtype descr = PyArray_DESCR(self) * cdef int offset */ __pyx_v_f = NULL; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":297 * cdef int t * cdef char* f = NULL * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< * cdef int offset * */ __pyx_t_7 = PyArray_DESCR(__pyx_v_self); __pyx_t_3 = ((PyObject *)__pyx_t_7); __Pyx_INCREF(__pyx_t_3); __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":300 * cdef int offset * * info.obj = self # <<<<<<<<<<<<<< * * if not PyDataType_HASFIELDS(descr): */ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or */ __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":303 * * if not PyDataType_HASFIELDS(descr): * t = descr.type_num # <<<<<<<<<<<<<< * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): */ __pyx_t_4 = __pyx_v_descr->type_num; __pyx_v_t = __pyx_t_4; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); if (!__pyx_t_2) { goto __pyx_L15_next_or; } else { } __pyx_t_2 = (__pyx_v_little_endian != 0); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L14_bool_binop_done; } __pyx_L15_next_or:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":305 * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" */ __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L14_bool_binop_done; } __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L14_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ if (unlikely(__pyx_t_1)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 306, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":304 * if not PyDataType_HASFIELDS(descr): * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":307 * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" */ switch (__pyx_v_t) { case NPY_BYTE: __pyx_v_f = ((char *)"b"); break; case NPY_UBYTE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":308 * raise ValueError(u"Non-native byte order not supported") * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" */ __pyx_v_f = ((char *)"B"); break; case NPY_SHORT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":309 * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" */ __pyx_v_f = ((char *)"h"); break; case NPY_USHORT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":310 * elif t == NPY_UBYTE: f = "B" * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" */ __pyx_v_f = ((char *)"H"); break; case NPY_INT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":311 * elif t == NPY_SHORT: f = "h" * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" */ __pyx_v_f = ((char *)"i"); break; case NPY_UINT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":312 * elif t == NPY_USHORT: f = "H" * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" */ __pyx_v_f = ((char *)"I"); break; case NPY_LONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":313 * elif t == NPY_INT: f = "i" * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" */ __pyx_v_f = ((char *)"l"); break; case NPY_ULONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":314 * elif t == NPY_UINT: f = "I" * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" */ __pyx_v_f = ((char *)"L"); break; case NPY_LONGLONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":315 * elif t == NPY_LONG: f = "l" * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" */ __pyx_v_f = ((char *)"q"); break; case NPY_ULONGLONG: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":316 * elif t == NPY_ULONG: f = "L" * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" */ __pyx_v_f = ((char *)"Q"); break; case NPY_FLOAT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":317 * elif t == NPY_LONGLONG: f = "q" * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" */ __pyx_v_f = ((char *)"f"); break; case NPY_DOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":318 * elif t == NPY_ULONGLONG: f = "Q" * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" */ __pyx_v_f = ((char *)"d"); break; case NPY_LONGDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":319 * elif t == NPY_FLOAT: f = "f" * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" */ __pyx_v_f = ((char *)"g"); break; case NPY_CFLOAT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":320 * elif t == NPY_DOUBLE: f = "d" * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" */ __pyx_v_f = ((char *)"Zf"); break; case NPY_CDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":321 * elif t == NPY_LONGDOUBLE: f = "g" * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" */ __pyx_v_f = ((char *)"Zd"); break; case NPY_CLONGDOUBLE: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":322 * elif t == NPY_CFLOAT: f = "Zf" * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f = "O" * else: */ __pyx_v_f = ((char *)"Zg"); break; case NPY_OBJECT: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":323 * elif t == NPY_CDOUBLE: f = "Zd" * elif t == NPY_CLONGDOUBLE: f = "Zg" * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ __pyx_v_f = ((char *)"O"); break; default: /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":325 * elif t == NPY_OBJECT: f = "O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * info.format = f * return */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 325, __pyx_L1_error) break; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":326 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f # <<<<<<<<<<<<<< * return * else: */ __pyx_v_info->format = __pyx_v_f; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":327 * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * info.format = f * return # <<<<<<<<<<<<<< * else: * info.format = PyObject_Malloc(_buffer_format_string_len) */ __pyx_r = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":302 * info.obj = self * * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< * t = descr.type_num * if ((descr.byteorder == c'>' and little_endian) or */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":329 * return * else: * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 */ /*else*/ { __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":330 * else: * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< * offset = 0 * f = _util_dtypestring(descr, info.format + 1, */ (__pyx_v_info->format[0]) = '^'; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":331 * info.format = PyObject_Malloc(_buffer_format_string_len) * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 # <<<<<<<<<<<<<< * f = _util_dtypestring(descr, info.format + 1, * info.format + _buffer_format_string_len, */ __pyx_v_offset = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":332 * info.format[0] = c'^' # Native data types, manual alignment * offset = 0 * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< * info.format + _buffer_format_string_len, * &offset) */ __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error) __pyx_v_f = __pyx_t_9; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":335 * info.format + _buffer_format_string_len, * &offset) * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< * * def __releasebuffer__(ndarray self, Py_buffer* info): */ (__pyx_v_f[0]) = '\x00'; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< * # This implementation of getbuffer is geared towards Cython * # requirements, and does not yet fulfill the PEP. */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; if (__pyx_v_info->obj != NULL) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } goto __pyx_L2; __pyx_L0:; if (__pyx_v_info->obj == Py_None) { __Pyx_GOTREF(__pyx_v_info->obj); __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_descr); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) */ /* Python wrapper */ static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__releasebuffer__", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":339 * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) # <<<<<<<<<<<<<< * if sizeof(npy_intp) != sizeof(Py_ssize_t): * PyObject_Free(info.strides) */ PyObject_Free(__pyx_v_info->format); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":338 * * def __releasebuffer__(ndarray self, Py_buffer* info): * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * PyObject_Free(info.strides) * # info.shape was stored after info.strides in the same block */ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":341 * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): * PyObject_Free(info.strides) # <<<<<<<<<<<<<< * # info.shape was stored after info.strides in the same block * */ PyObject_Free(__pyx_v_info->strides); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":340 * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< * PyObject_Free(info.strides) * # info.shape was stored after info.strides in the same block */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":337 * f[0] = c'\0' # Terminate format string * * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< * if PyArray_HASFIELDS(self): * PyObject_Free(info.format) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(1, a) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":825 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(2, a, b) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 828, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(3, a, b, c) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 831, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(4, a, b, c, d) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * * cdef inline tuple PyDataType_SHAPE(dtype d): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< * else: * return () */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< * return d.subarray.shape * else: */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_empty_tuple); __pyx_r = __pyx_empty_tuple; goto __pyx_L0; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< * # Recursive utility function used in __getbuffer__ to get format * # string. The new location in the format string is returned. */ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { PyArray_Descr *__pyx_v_child = 0; int __pyx_v_endian_detector; int __pyx_v_little_endian; PyObject *__pyx_v_fields = 0; PyObject *__pyx_v_childname = NULL; PyObject *__pyx_v_new_offset = NULL; PyObject *__pyx_v_t = NULL; char *__pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; int __pyx_t_7; long __pyx_t_8; char *__pyx_t_9; __Pyx_RefNannySetupContext("_util_dtypestring", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":847 * * cdef dtype child * cdef int endian_detector = 1 # <<<<<<<<<<<<<< * cdef bint little_endian = ((&endian_detector)[0] != 0) * cdef tuple fields */ __pyx_v_endian_detector = 1; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":848 * cdef dtype child * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * cdef tuple fields * */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< * fields = descr.fields[childname] * child, new_offset = fields */ if (unlikely(__pyx_v_descr->names == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(1, 851, __pyx_L1_error) } __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 851, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":852 * * for childname in descr.names: * fields = descr.fields[childname] # <<<<<<<<<<<<<< * child, new_offset = fields * */ if (unlikely(__pyx_v_descr->fields == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 852, __pyx_L1_error) } __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":853 * for childname in descr.names: * fields = descr.fields[childname] * child, new_offset = fields # <<<<<<<<<<<<<< * * if (end - f) - (new_offset - offset[0]) < 15: */ if (likely(__pyx_v_fields != Py_None)) { PyObject* sequence = __pyx_v_fields; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(1, 853, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } else { __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 853, __pyx_L1_error) } if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); __pyx_t_4 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 856, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); if (!__pyx_t_7) { goto __pyx_L8_next_or; } else { } __pyx_t_7 = (__pyx_v_little_endian != 0); if (!__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_L8_next_or:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":859 * * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< * raise ValueError(u"Non-native byte order not supported") * # One could encode it in the format string and have Cython */ __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); if (__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); __pyx_t_6 = __pyx_t_7; __pyx_L7_bool_binop_done:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":860 * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * # One could encode it in the format string and have Cython * # complain instead, BUT: < and > in format strings also imply */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 860, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 860, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":870 * * # Output padding bytes * while offset[0] < new_offset: # <<<<<<<<<<<<<< * f[0] = 120 # "x"; pad byte * f += 1 */ while (1) { __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_6) break; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":871 * # Output padding bytes * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< * f += 1 * offset[0] += 1 */ (__pyx_v_f[0]) = 0x78; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":872 * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte * f += 1 # <<<<<<<<<<<<<< * offset[0] += 1 * */ __pyx_v_f = (__pyx_v_f + 1); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":873 * f[0] = 120 # "x"; pad byte * f += 1 * offset[0] += 1 # <<<<<<<<<<<<<< * * offset[0] += child.itemsize */ __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":875 * offset[0] += 1 * * offset[0] += child.itemsize # <<<<<<<<<<<<<< * * if not PyDataType_HASFIELDS(child): */ __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< * t = child.type_num * if end - f < 5: */ __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); if (__pyx_t_6) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":878 * * if not PyDataType_HASFIELDS(child): * t = child.type_num # <<<<<<<<<<<<<< * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); __pyx_t_4 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short.") * */ __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); if (unlikely(__pyx_t_6)) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 880, __pyx_L1_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short.") * */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":883 * * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 98; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":884 * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 66; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":885 * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x68; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":886 * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 72; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":887 * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x69; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":888 * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 73; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":889 * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x6C; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":890 * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 76; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":891 * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x71; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":892 * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 81; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":893 * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x66; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":894 * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x64; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":895 * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x67; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":896 * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x66; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":897 * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x64; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":898 * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: */ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; (__pyx_v_f[1]) = 0x67; __pyx_v_f = (__pyx_v_f + 1); goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":899 * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(__pyx_t_6)) { (__pyx_v_f[0]) = 79; goto __pyx_L15; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":901 * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< * f += 1 * else: */ /*else*/ { __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 901, __pyx_L1_error) } __pyx_L15:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":902 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * f += 1 # <<<<<<<<<<<<<< * else: * # Cython ignores struct boundary information ("T{...}"), */ __pyx_v_f = (__pyx_v_f + 1); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< * t = child.type_num * if end - f < 5: */ goto __pyx_L13; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":906 * # Cython ignores struct boundary information ("T{...}"), * # so don't output it * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< * return f * */ /*else*/ { __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 906, __pyx_L1_error) __pyx_v_f = __pyx_t_9; } __pyx_L13:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< * fields = descr.fields[childname] * child, new_offset = fields */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":907 * # so don't output it * f = _util_dtypestring(child, f, end, offset) * return f # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v_f; goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< * # Recursive utility function used in __getbuffer__ to get format * # string. The new location in the format string is returned. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_child); __Pyx_XDECREF(__pyx_v_fields); __Pyx_XDECREF(__pyx_v_childname); __Pyx_XDECREF(__pyx_v_new_offset); __Pyx_XDECREF(__pyx_v_t); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1023 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< * PyArray_SetBaseObject(arr, base) * */ Py_INCREF(__pyx_v_base); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1024 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * * cdef inline object get_array_base(ndarray arr): */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1027 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< * if base is NULL: * return None */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1029 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< * return base * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< * return None * return base */ } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1030 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< * * # Versions of the import_* functions which are more suitable for */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< * base = PyArray_BASE(arr) * if base is NULL: */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * _import_array() */ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_array", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1036 * cdef inline int import_array() except -1: * try: * _import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1036, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1037 * try: * _import_array() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.multiarray failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1037, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1038, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1038, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< * _import_array() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: * _import_array() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_umath", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1042 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1042, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1043 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1043, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1044, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1044, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; __Pyx_RefNannySetupContext("import_ufunc", 0); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1048 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1048, __pyx_L3_error) /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1049 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1049, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1050 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< */ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1050, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __PYX_ERR(1, 1050, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< * _import_umath() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec_rectangular_overlap(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_rectangular_overlap}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "rectangular_overlap", 0, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_DTYPE, __pyx_k_DTYPE, sizeof(__pyx_k_DTYPE), 0, 0, 1, 1}, {&__pyx_kp_u_Exact_mode_has_not_been_implemen, __pyx_k_Exact_mode_has_not_been_implemen, sizeof(__pyx_k_Exact_mode_has_not_been_implemen), 0, 1, 0, 0}, {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, {&__pyx_n_s_dx, __pyx_k_dx, sizeof(__pyx_k_dx), 0, 0, 1, 1}, {&__pyx_n_s_dy, __pyx_k_dy, sizeof(__pyx_k_dy), 0, 0, 1, 1}, {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1}, {&__pyx_n_s_frac, __pyx_k_frac, sizeof(__pyx_k_frac), 0, 0, 1, 1}, {&__pyx_n_s_height, __pyx_k_height, sizeof(__pyx_k_height), 0, 0, 1, 1}, {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, {&__pyx_n_s_nx, __pyx_k_nx, sizeof(__pyx_k_nx), 0, 0, 1, 1}, {&__pyx_n_s_ny, __pyx_k_ny, sizeof(__pyx_k_ny), 0, 0, 1, 1}, {&__pyx_n_s_pxmax, __pyx_k_pxmax, sizeof(__pyx_k_pxmax), 0, 0, 1, 1}, {&__pyx_n_s_pxmin, __pyx_k_pxmin, sizeof(__pyx_k_pxmin), 0, 0, 1, 1}, {&__pyx_n_s_pymax, __pyx_k_pymax, sizeof(__pyx_k_pymax), 0, 0, 1, 1}, {&__pyx_n_s_pymin, __pyx_k_pymin, sizeof(__pyx_k_pymin), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_rectangular_overlap_grid, __pyx_k_rectangular_overlap_grid, sizeof(__pyx_k_rectangular_overlap_grid), 0, 0, 1, 1}, {&__pyx_n_u_rectangular_overlap_grid, __pyx_k_rectangular_overlap_grid, sizeof(__pyx_k_rectangular_overlap_grid), 0, 1, 0, 1}, {&__pyx_kp_s_regions__geometry_rectangular_ov, __pyx_k_regions__geometry_rectangular_ov, sizeof(__pyx_k_regions__geometry_rectangular_ov), 0, 0, 1, 0}, {&__pyx_n_s_regions__geometry_rectangular_ov_2, __pyx_k_regions__geometry_rectangular_ov_2, sizeof(__pyx_k_regions__geometry_rectangular_ov_2), 0, 0, 1, 1}, {&__pyx_n_s_subpixels, __pyx_k_subpixels, sizeof(__pyx_k_subpixels), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_theta, __pyx_k_theta, sizeof(__pyx_k_theta), 0, 0, 1, 1}, {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, {&__pyx_n_s_use_exact, __pyx_k_use_exact, sizeof(__pyx_k_use_exact), 0, 0, 1, 1}, {&__pyx_n_s_width, __pyx_k_width, sizeof(__pyx_k_width), 0, 0, 1, 1}, {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, {&__pyx_n_s_xmax, __pyx_k_xmax, sizeof(__pyx_k_xmax), 0, 0, 1, 1}, {&__pyx_n_s_xmin, __pyx_k_xmin, sizeof(__pyx_k_xmin), 0, 0, 1, 1}, {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, {&__pyx_n_s_ymax, __pyx_k_ymax, sizeof(__pyx_k_ymax), 0, 0, 1, 1}, {&__pyx_n_s_ymin, __pyx_k_ymin, sizeof(__pyx_k_ymin), 0, 0, 1, 1}, {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 74, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 84, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error) __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 856, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1038, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "regions/_geometry/rectangular_overlap.pyx":74 * * if use_exact == 1: * raise NotImplementedError("Exact mode has not been implemented for " # <<<<<<<<<<<<<< * "rectangular apertures") * */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_Exact_mode_has_not_been_implemen); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 74, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< * * info.buf = PyArray_DATA(self) */ __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":306 * if ((descr.byteorder == c'>' and little_endian) or * (descr.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * if t == NPY_BYTE: f = "b" * elif t == NPY_UBYTE: f = "B" */ __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1038 * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 1038, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 1044, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "regions/_geometry/rectangular_overlap.pyx":29 * * * def rectangular_overlap_grid(double xmin, double xmax, double ymin, # <<<<<<<<<<<<<< * double ymax, int nx, int ny, double width, * double height, double theta, int use_exact, */ __pyx_tuple__9 = PyTuple_Pack(22, __pyx_n_s_xmin, __pyx_n_s_xmax, __pyx_n_s_ymin, __pyx_n_s_ymax, __pyx_n_s_nx, __pyx_n_s_ny, __pyx_n_s_width, __pyx_n_s_height, __pyx_n_s_theta, __pyx_n_s_use_exact, __pyx_n_s_subpixels, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_dx, __pyx_n_s_dy, __pyx_n_s_pxmin, __pyx_n_s_pxmax, __pyx_n_s_pymin, __pyx_n_s_pymax, __pyx_n_s_frac); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(11, 0, 22, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_regions__geometry_rectangular_ov, __pyx_n_s_rectangular_overlap_grid, 29, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 sizeof(PyTypeObject), #else sizeof(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(3, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(4, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error) __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error) __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 918, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #if PY_MAJOR_VERSION < 3 #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC void #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #else #ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyObject * #else #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC initrectangular_overlap(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC initrectangular_overlap(void) #else __Pyx_PyMODINIT_FUNC PyInit_rectangular_overlap(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_rectangular_overlap(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec_rectangular_overlap(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module 'rectangular_overlap' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_rectangular_overlap(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("rectangular_overlap", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_regions___geometry__rectangular_overlap) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "regions._geometry.rectangular_overlap")) { if (unlikely(PyDict_SetItemString(modules, "regions._geometry.rectangular_overlap", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); (void)__Pyx_modinit_type_init_code(); if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error; (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "regions/_geometry/rectangular_overlap.pyx":6 * unicode_literals) * * import numpy as np # <<<<<<<<<<<<<< * cimport numpy as np * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/rectangular_overlap.pyx":10 * * * __all__ = ['rectangular_overlap_grid'] # <<<<<<<<<<<<<< * * */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_u_rectangular_overlap_grid); __Pyx_GIVEREF(__pyx_n_u_rectangular_overlap_grid); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_u_rectangular_overlap_grid); if (PyDict_SetItem(__pyx_d, __pyx_n_s_all, __pyx_t_1) < 0) __PYX_ERR(0, 10, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "regions/_geometry/rectangular_overlap.pyx":23 * from cpython cimport bool * * DTYPE = np.float64 # <<<<<<<<<<<<<< * ctypedef np.float64_t DTYPE_t * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE, __pyx_t_2) < 0) __PYX_ERR(0, 23, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/rectangular_overlap.pyx":29 * * * def rectangular_overlap_grid(double xmin, double xmax, double ymin, # <<<<<<<<<<<<<< * double ymax, int nx, int ny, double width, * double height, double theta, int use_exact, */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7regions_9_geometry_19rectangular_overlap_1rectangular_overlap_grid, NULL, __pyx_n_s_regions__geometry_rectangular_ov_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_rectangular_overlap_grid, __pyx_t_2) < 0) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "regions/_geometry/rectangular_overlap.pyx":1 * # Licensed under a 3-clause BSD style license - see LICENSE.rst # <<<<<<<<<<<<<< * # cython: language_level=3 * from __future__ import (absolute_import, division, print_function, */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "../../../software/anaconda3/envs/regions/lib/python3.7/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< * try: * _import_umath() */ /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init regions._geometry.rectangular_overlap", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init regions._geometry.rectangular_overlap"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* IsLittleEndian */ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) { union { uint32_t u32; uint8_t u8[4]; } S; S.u32 = 0x01020304; return S.u8[0] == 4; } /* BufferFormatCheck */ static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type) { stack[0].field = &ctx->root; stack[0].parent_offset = 0; ctx->root.type = type; ctx->root.name = "buffer dtype"; ctx->root.offset = 0; ctx->head = stack; ctx->head->field = &ctx->root; ctx->fmt_offset = 0; ctx->head->parent_offset = 0; ctx->new_packmode = '@'; ctx->enc_packmode = '@'; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->is_complex = 0; ctx->is_valid_array = 0; ctx->struct_alignment = 0; while (type->typegroup == 'S') { ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = 0; type = type->fields->type; } } static int __Pyx_BufFmt_ParseNumber(const char** ts) { int count; const char* t = *ts; if (*t < '0' || *t > '9') { return -1; } else { count = *t++ - '0'; while (*t >= '0' && *t <= '9') { count *= 10; count += *t++ - '0'; } } *ts = t; return count; } static int __Pyx_BufFmt_ExpectNumber(const char **ts) { int number = __Pyx_BufFmt_ParseNumber(ts); if (number == -1) PyErr_Format(PyExc_ValueError,\ "Does not understand character buffer dtype format string ('%c')", **ts); return number; } static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { PyErr_Format(PyExc_ValueError, "Unexpected format string character: '%c'", ch); } static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { switch (ch) { case 'c': return "'char'"; case 'b': return "'signed char'"; case 'B': return "'unsigned char'"; case 'h': return "'short'"; case 'H': return "'unsigned short'"; case 'i': return "'int'"; case 'I': return "'unsigned int'"; case 'l': return "'long'"; case 'L': return "'unsigned long'"; case 'q': return "'long long'"; case 'Q': return "'unsigned long long'"; case 'f': return (is_complex ? "'complex float'" : "'float'"); case 'd': return (is_complex ? "'complex double'" : "'double'"); case 'g': return (is_complex ? "'complex long double'" : "'long double'"); case 'T': return "a struct"; case 'O': return "Python object"; case 'P': return "a pointer"; case 's': case 'p': return "a string"; case 0: return "end"; default: return "unparseable format string"; } } static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return 2; case 'i': case 'I': case 'l': case 'L': return 4; case 'q': case 'Q': return 8; case 'f': return (is_complex ? 8 : 4); case 'd': return (is_complex ? 16 : 8); case 'g': { PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); return 0; } case 'O': case 'P': return sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { switch (ch) { case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(short); case 'i': case 'I': return sizeof(int); case 'l': case 'L': return sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(float) * (is_complex ? 2 : 1); case 'd': return sizeof(double) * (is_complex ? 2 : 1); case 'g': return sizeof(long double) * (is_complex ? 2 : 1); case 'O': case 'P': return sizeof(void*); default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } typedef struct { char c; short x; } __Pyx_st_short; typedef struct { char c; int x; } __Pyx_st_int; typedef struct { char c; long x; } __Pyx_st_long; typedef struct { char c; float x; } __Pyx_st_float; typedef struct { char c; double x; } __Pyx_st_double; typedef struct { char c; long double x; } __Pyx_st_longdouble; typedef struct { char c; void *x; } __Pyx_st_void_p; #ifdef HAVE_LONG_LONG typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_st_float) - sizeof(float); case 'd': return sizeof(__Pyx_st_double) - sizeof(double); case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } /* These are for computing the padding at the end of the struct to align on the first member of the struct. This will probably the same as above, but we don't have any guarantees. */ typedef struct { short x; char c; } __Pyx_pad_short; typedef struct { int x; char c; } __Pyx_pad_int; typedef struct { long x; char c; } __Pyx_pad_long; typedef struct { float x; char c; } __Pyx_pad_float; typedef struct { double x; char c; } __Pyx_pad_double; typedef struct { long double x; char c; } __Pyx_pad_longdouble; typedef struct { void *x; char c; } __Pyx_pad_void_p; #ifdef HAVE_LONG_LONG typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; #endif static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { switch (ch) { case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); #ifdef HAVE_LONG_LONG case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); #endif case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); default: __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { switch (ch) { case 'c': return 'H'; case 'b': case 'h': case 'i': case 'l': case 'q': case 's': case 'p': return 'I'; case 'B': case 'H': case 'I': case 'L': case 'Q': return 'U'; case 'f': case 'd': case 'g': return (is_complex ? 'C' : 'R'); case 'O': return 'O'; case 'P': return 'P'; default: { __Pyx_BufFmt_RaiseUnexpectedChar(ch); return 0; } } } static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { if (ctx->head == NULL || ctx->head->field == &ctx->root) { const char* expected; const char* quote; if (ctx->head == NULL) { expected = "end"; quote = ""; } else { expected = ctx->head->field->type->name; quote = "'"; } PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected %s%s%s but got %s", quote, expected, quote, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); } else { __Pyx_StructField* field = ctx->head->field; __Pyx_StructField* parent = (ctx->head - 1)->field; PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), parent->type->name, field->name); } } static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { char group; size_t size, offset, arraysize = 1; if (ctx->enc_type == 0) return 0; if (ctx->head->field->type->arraysize[0]) { int i, ndim = 0; if (ctx->enc_type == 's' || ctx->enc_type == 'p') { ctx->is_valid_array = ctx->head->field->type->ndim == 1; ndim = 1; if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %zu", ctx->head->field->type->arraysize[0], ctx->enc_count); return -1; } } if (!ctx->is_valid_array) { PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", ctx->head->field->type->ndim, ndim); return -1; } for (i = 0; i < ctx->head->field->type->ndim; i++) { arraysize *= ctx->head->field->type->arraysize[i]; } ctx->is_valid_array = 0; ctx->enc_count = 1; } group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); do { __Pyx_StructField* field = ctx->head->field; __Pyx_TypeInfo* type = field->type; if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); } else { size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); } if (ctx->enc_packmode == '@') { size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); size_t align_mod_offset; if (align_at == 0) return -1; align_mod_offset = ctx->fmt_offset % align_at; if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; if (ctx->struct_alignment == 0) ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, ctx->is_complex); } if (type->size != size || type->typegroup != group) { if (type->typegroup == 'C' && type->fields != NULL) { size_t parent_offset = ctx->head->parent_offset + field->offset; ++ctx->head; ctx->head->field = type->fields; ctx->head->parent_offset = parent_offset; continue; } if ((type->typegroup == 'H' || group == 'H') && type->size == size) { } else { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } } offset = ctx->head->parent_offset + field->offset; if (ctx->fmt_offset != offset) { PyErr_Format(PyExc_ValueError, "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); return -1; } ctx->fmt_offset += size; if (arraysize) ctx->fmt_offset += (arraysize - 1) * size; --ctx->enc_count; while (1) { if (field == &ctx->root) { ctx->head = NULL; if (ctx->enc_count != 0) { __Pyx_BufFmt_RaiseExpected(ctx); return -1; } break; } ctx->head->field = ++field; if (field->type == NULL) { --ctx->head; field = ctx->head->field; continue; } else if (field->type->typegroup == 'S') { size_t parent_offset = ctx->head->parent_offset + field->offset; if (field->type->fields->type == NULL) continue; field = field->type->fields; ++ctx->head; ctx->head->field = field; ctx->head->parent_offset = parent_offset; break; } else { break; } } } while (ctx->enc_count); ctx->enc_type = 0; ctx->is_complex = 0; return 0; } static PyObject * __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { const char *ts = *tsp; int i = 0, number; int ndim = ctx->head->field->type->ndim; ; ++ts; if (ctx->new_count != 1) { PyErr_SetString(PyExc_ValueError, "Cannot handle repeated arrays in format string"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; while (*ts && *ts != ')') { switch (*ts) { case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; default: break; } number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) return PyErr_Format(PyExc_ValueError, "Expected a dimension of size %zu, got %d", ctx->head->field->type->arraysize[i], number); if (*ts != ',' && *ts != ')') return PyErr_Format(PyExc_ValueError, "Expected a comma in format string, got '%c'", *ts); if (*ts == ',') ts++; i++; } if (i != ndim) return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", ctx->head->field->type->ndim, i); if (!*ts) { PyErr_SetString(PyExc_ValueError, "Unexpected end of format string, expected ')'"); return NULL; } ctx->is_valid_array = 1; ctx->new_count = 1; *tsp = ++ts; return Py_None; } static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { int got_Z = 0; while (1) { switch(*ts) { case 0: if (ctx->enc_type != 0 && ctx->head == NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; if (ctx->head != NULL) { __Pyx_BufFmt_RaiseExpected(ctx); return NULL; } return ts; case ' ': case '\r': case '\n': ++ts; break; case '<': if (!__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '>': case '!': if (__Pyx_Is_Little_Endian()) { PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); return NULL; } ctx->new_packmode = '='; ++ts; break; case '=': case '@': case '^': ctx->new_packmode = *ts++; break; case 'T': { const char* ts_after_sub; size_t i, struct_count = ctx->new_count; size_t struct_alignment = ctx->struct_alignment; ctx->new_count = 1; ++ts; if (*ts != '{') { PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; ctx->enc_count = 0; ctx->struct_alignment = 0; ++ts; ts_after_sub = ts; for (i = 0; i != struct_count; ++i) { ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); if (!ts_after_sub) return NULL; } ts = ts_after_sub; if (struct_alignment) ctx->struct_alignment = struct_alignment; } break; case '}': { size_t alignment = ctx->struct_alignment; ++ts; if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_type = 0; if (alignment && ctx->fmt_offset % alignment) { ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); } } return ts; case 'x': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->fmt_offset += ctx->new_count; ctx->new_count = 1; ctx->enc_count = 0; ctx->enc_type = 0; ctx->enc_packmode = ctx->new_packmode; ++ts; break; case 'Z': got_Z = 1; ++ts; if (*ts != 'f' && *ts != 'd' && *ts != 'g') { __Pyx_BufFmt_RaiseUnexpectedChar('Z'); return NULL; } CYTHON_FALLTHROUGH; case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': case 'l': case 'L': case 'q': case 'Q': case 'f': case 'd': case 'g': case 'O': case 'p': if (ctx->enc_type == *ts && got_Z == ctx->is_complex && ctx->enc_packmode == ctx->new_packmode) { ctx->enc_count += ctx->new_count; ctx->new_count = 1; got_Z = 0; ++ts; break; } CYTHON_FALLTHROUGH; case 's': if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; ctx->enc_count = ctx->new_count; ctx->enc_packmode = ctx->new_packmode; ctx->enc_type = *ts; ctx->is_complex = got_Z; ++ts; ctx->new_count = 1; got_Z = 0; break; case ':': ++ts; while(*ts != ':') ++ts; ++ts; break; case '(': if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; break; default: { int number = __Pyx_BufFmt_ExpectNumber(&ts); if (number == -1) return NULL; ctx->new_count = (size_t)number; } } } } /* BufferGetAndValidate */ static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { if (unlikely(info->buf == NULL)) return; if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; __Pyx_ReleaseBuffer(info); } static void __Pyx_ZeroBuffer(Py_buffer* buf) { buf->buf = NULL; buf->obj = NULL; buf->strides = __Pyx_zeros; buf->shape = __Pyx_zeros; buf->suboffsets = __Pyx_minusones; } static int __Pyx__GetBufferAndValidate( Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack) { buf->buf = NULL; if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { __Pyx_ZeroBuffer(buf); return -1; } if (unlikely(buf->ndim != nd)) { PyErr_Format(PyExc_ValueError, "Buffer has wrong number of dimensions (expected %d, got %d)", nd, buf->ndim); goto fail; } if (!cast) { __Pyx_BufFmt_Context ctx; __Pyx_BufFmt_Init(&ctx, stack, dtype); if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; } if (unlikely((size_t)buf->itemsize != dtype->size)) { PyErr_Format(PyExc_ValueError, "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", buf->itemsize, (buf->itemsize > 1) ? "s" : "", dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); goto fail; } if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; return 0; fail:; __Pyx_SafeReleaseBuffer(buf); return -1; } /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* BufferIndexError */ static void __Pyx_RaiseBufferIndexError(int axis) { PyErr_Format(PyExc_IndexError, "Out of bounds on buffer access (axis %d)", axis); } /* WriteUnraisableException */ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback, CYTHON_UNUSED int nogil) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_PyThreadState_declare #ifdef WITH_THREAD PyGILState_STATE state; if (nogil) state = PyGILState_Ensure(); #ifdef _MSC_VER else state = (PyGILState_STATE)-1; #endif #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } #ifdef WITH_THREAD if (nogil) PyGILState_Release(state); #endif } /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* DictGetItem */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); if (unlikely(!value)) { if (!PyErr_Occurred()) { if (unlikely(PyTuple_Check(key))) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) { PyErr_SetObject(PyExc_KeyError, args); Py_DECREF(args); } } else { PyErr_SetObject(PyExc_KeyError, key); } } return NULL; } Py_INCREF(value); return value; } #endif /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* RaiseNoneIterError */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; #ifdef Py_LIMITED_API PyObject *py_basicsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #ifndef Py_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if ((size_t)basicsize < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(result); return NULL; } #endif /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.')) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); return -1; } static void __Pyx_ReleaseBuffer(Py_buffer *view) { PyObject *obj = view->obj; if (!obj) return; if (PyObject_CheckBuffer(obj)) { PyBuffer_Release(view); return; } if ((0)) {} else if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); view->obj = NULL; Py_DECREF(obj); } #endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return ::std::complex< float >(x, y); } #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return x + y*(__pyx_t_float_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { __pyx_t_float_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabsf(b.real) >= fabsf(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { float r = b.imag / b.real; float s = (float)(1.0) / (b.real + b.imag * r); return __pyx_t_float_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { float r = b.real / b.imag; float s = (float)(1.0) / (b.imag + b.real * r); return __pyx_t_float_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else { float denom = b.real * b.real + b.imag * b.imag; return __pyx_t_float_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrtf(z.real*z.real + z.imag*z.imag); #else return hypotf(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; float r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { float denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(a, a); case 3: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, a); case 4: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = powf(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2f(0.0, -1.0); } } else { r = __Pyx_c_abs_float(a); theta = atan2f(a.imag, a.real); } lnr = logf(r); z_r = expf(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cosf(z_theta); z.imag = z_r * sinf(z_theta); return z; } #endif #endif /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return ::std::complex< double >(x, y); } #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return x + y*(__pyx_t_double_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { __pyx_t_double_complex z; z.real = x; z.imag = y; return z; } #endif /* Arithmetic */ #if CYTHON_CCOMPLEX #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real * b.real - a.imag * b.imag; z.imag = a.real * b.imag + a.imag * b.real; return z; } #if 1 static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabs(b.real) >= fabs(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { double r = b.imag / b.real; double s = (double)(1.0) / (b.real + b.imag * r); return __pyx_t_double_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { double r = b.real / b.imag; double s = (double)(1.0) / (b.imag + b.real * r); return __pyx_t_double_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else { double denom = b.real * b.real + b.imag * b.imag; return __pyx_t_double_complex_from_parts( (a.real * b.real + a.imag * b.imag) / denom, (a.imag * b.real - a.real * b.imag) / denom); } } #endif static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrt(z.real*z.real + z.imag*z.imag); #else return hypot(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; double r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { double denom = a.real * a.real + a.imag * a.imag; a.real = a.real / denom; a.imag = -a.imag / denom; b.real = -b.real; } switch ((int)b.real) { case 0: z.real = 1; z.imag = 0; return z; case 1: return a; case 2: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(a, a); case 3: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, a); case 4: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if (b.imag == 0) { z.real = pow(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2(0.0, -1.0); } } else { r = __Pyx_c_abs_double(a); theta = atan2(a.imag, a.real); } lnr = log(r); z_r = exp(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cos(z_theta); z.imag = z_r * sin(z_theta); return z; } #endif #endif /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(enum NPY_TYPES) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(enum NPY_TYPES) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntFromPy */ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (unsigned int) 1), const_zero = (unsigned int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(unsigned int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (unsigned int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned int) 0; case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0]) case 2: if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) { return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; case 3: if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) { return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; case 4: if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT) { return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (unsigned int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(unsigned int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned int) 0; case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, +digits[0]) case -2: if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 2: if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case -3: if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 3: if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case -4: if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; case 4: if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); } } break; } #endif if (sizeof(unsigned int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else unsigned int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (unsigned int) -1; } } else { unsigned int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (unsigned int) -1; val = __Pyx_PyInt_As_unsigned_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned int"); return (unsigned int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned int"); return (unsigned int) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; ip) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ regions-0.4/regions/_geometry/rectangular_overlap.pyx0000644000076600000240000000776213501414013023331 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst # cython: language_level=3 from __future__ import (absolute_import, division, print_function, unicode_literals) import numpy as np cimport numpy as np __all__ = ['rectangular_overlap_grid'] cdef extern from "math.h": double asin(double x) double sin(double x) double cos(double x) double sqrt(double x) double fabs(double x) from cpython cimport bool DTYPE = np.float64 ctypedef np.float64_t DTYPE_t cimport cython def rectangular_overlap_grid(double xmin, double xmax, double ymin, double ymax, int nx, int ny, double width, double height, double theta, int use_exact, int subpixels): """ rectangular_overlap_grid(xmin, xmax, ymin, ymax, nx, ny, width, height, use_exact, subpixels) Area of overlap between a rectangle and a pixel grid. The rectangle is centered on the origin. Parameters ---------- xmin, xmax, ymin, ymax : float Extent of the grid in the x and y direction. nx, ny : int Grid dimensions. width : float The width of the rectangle height : float The height of the rectangle theta : float The position angle of the rectangle in radians (counterclockwise). use_exact : 0 or 1 If set to 1, calculates the exact overlap, while if set to 0, uses a subpixel sampling method with ``subpixel`` subpixels in each direction. subpixels : int If ``use_exact`` is 0, each pixel is resampled by this factor in each dimension. Thus, each pixel is divided into ``subpixels ** 2`` subpixels. Returns ------- frac : `~numpy.ndarray` 2-d array giving the fraction of the overlap. """ cdef unsigned int i, j cdef double x, y, dx, dy cdef double pxmin, pxmax, pymin, pymax # Define output array cdef np.ndarray[DTYPE_t, ndim=2] frac = np.zeros([ny, nx], dtype=DTYPE) if use_exact == 1: raise NotImplementedError("Exact mode has not been implemented for " "rectangular apertures") # Find the width of each element in x and y dx = (xmax - xmin) / nx dy = (ymax - ymin) / ny # TODO: can implement a bounding box here for efficiency (as for the # circular and elliptical aperture photometry) for i in range(nx): pxmin = xmin + i * dx # lower end of pixel pxmax = pxmin + dx # upper end of pixel for j in range(ny): pymin = ymin + j * dy pymax = pymin + dy frac[j, i] = rectangular_overlap_single_subpixel( pxmin, pymin, pxmax, pymax, width, height, theta, subpixels) return frac cdef double rectangular_overlap_single_subpixel(double x0, double y0, double x1, double y1, double width, double height, double theta, int subpixels): """ Return the fraction of overlap between a rectangle and a single pixel with given extent, using a sub-pixel sampling method. """ cdef unsigned int i, j cdef double x, y cdef double frac = 0. # Accumulator. cdef double cos_theta = cos(theta) cdef double sin_theta = sin(theta) cdef double half_width, half_height half_width = width / 2. half_height = height / 2. dx = (x1 - x0) / subpixels dy = (y1 - y0) / subpixels x = x0 - 0.5 * dx for i in range(subpixels): x += dx y = y0 - 0.5 * dy for j in range(subpixels): y += dy # Transform into frame of rotated rectangle x_tr = y * sin_theta + x * cos_theta y_tr = y * cos_theta - x * sin_theta if fabs(x_tr) < half_width and fabs(y_tr) < half_height: frac += 1. return frac / (subpixels * subpixels) regions-0.4/regions/_geometry/tests/0000755000076600000240000000000013501657425017676 5ustar deilstaff00000000000000regions-0.4/regions/_geometry/tests/__init__.py0000644000076600000240000000017013336761120021777 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ This package contains affiliated package tests. """ regions-0.4/regions/_geometry/tests/test_circular_overlap_grid.py0000644000076600000240000000203213477731541025651 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import (absolute_import, division, print_function, unicode_literals) import itertools from numpy.testing import assert_allclose import pytest from .. import circular_overlap_grid grid_sizes = [50, 500, 1000] circ_sizes = [0.2, 0.4, 0.8] use_exact = [0, 1] subsamples = [1, 5, 10] arg_list = ['grid_size', 'circ_size', 'use_exact', 'subsample'] @pytest.mark.parametrize(('grid_size', 'circ_size', 'use_exact', 'subsample'), list(itertools.product(grid_sizes, circ_sizes, use_exact, subsamples))) def test_circular_overlap_grid(grid_size, circ_size, use_exact, subsample): """ Test normalization of the overlap grid to make sure that a fully enclosed pixel has a value of 1.0. """ g = circular_overlap_grid(-1.0, 1.0, -1.0, 1.0, grid_size, grid_size, circ_size, use_exact, subsample) assert_allclose(g.max(), 1.0) regions-0.4/regions/_geometry/tests/test_elliptical_overlap_grid.py0000644000076600000240000000250713477731541026176 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import (absolute_import, division, print_function, unicode_literals) import itertools from numpy.testing import assert_allclose import pytest from .. import elliptical_overlap_grid grid_sizes = [50, 500, 1000] maj_sizes = [0.2, 0.4, 0.8] min_sizes = [0.2, 0.4, 0.8] angles = [0.0, 0.5, 1.0] use_exact = [0, 1] subsamples = [1, 5, 10] arg_list = ['grid_size', 'maj_size', 'min_size', 'angle', 'use_exact', 'subsample'] @pytest.mark.parametrize(('grid_size', 'maj_size', 'min_size', 'angle', 'use_exact', 'subsample'), list(itertools.product(grid_sizes, maj_sizes, min_sizes, angles, use_exact, subsamples))) def test_elliptical_overlap_grid(grid_size, maj_size, min_size, angle, use_exact, subsample): """ Test normalization of the overlap grid to make sure that a fully enclosed pixel has a value of 1.0. """ g = elliptical_overlap_grid(-1.0, 1.0, -1.0, 1.0, grid_size, grid_size, maj_size, min_size, angle, use_exact, subsample) assert_allclose(g.max(), 1.0) regions-0.4/regions/_geometry/tests/test_rectangular_overlap_grid.py0000644000076600000240000000204713477731541026362 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import (absolute_import, division, print_function, unicode_literals) import itertools from numpy.testing import assert_allclose import pytest from .. import rectangular_overlap_grid grid_sizes = [50, 500, 1000] rect_sizes = [0.2, 0.4, 0.8] angles = [0.0, 0.5, 1.0] subsamples = [1, 5, 10] arg_list = ['grid_size', 'rect_size', 'angle', 'subsample'] @pytest.mark.parametrize(('grid_size', 'rect_size', 'angle', 'subsample'), list(itertools.product(grid_sizes, rect_sizes, angles, subsamples))) def test_rectangular_overlap_grid(grid_size, rect_size, angle, subsample): """ Test normalization of the overlap grid to make sure that a fully enclosed pixel has a value of 1.0. """ g = rectangular_overlap_grid(-1.0, 1.0, -1.0, 1.0, grid_size, grid_size, rect_size, rect_size, angle, 0, subsample) assert_allclose(g.max(), 1.0) regions-0.4/regions/_utils/0000755000076600000240000000000013501657425016041 5ustar deilstaff00000000000000regions-0.4/regions/_utils/__init__.py0000644000076600000240000000016513336761120020146 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """Region utilities. """ from .wcs_helpers import * regions-0.4/regions/_utils/examples.py0000644000076600000240000001614513501414013020220 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from astropy.utils import lazyproperty from astropy.io import fits from astropy.wcs import WCS from astropy.coordinates import SkyCoord from astropy.table import Table from astropy.table import vstack as table_vstack from ..core.pixcoord import PixCoord __all__ = [ 'make_example_dataset', ] def make_example_dataset(data='simulated', config=None): """Make example dataset. This is a factory function for ``ExampleDataset`` objects. The following config options are available (default values shown): * ``crval = 0, 0`` * ``crpix = 180, 90`` * ``cdelt = -1, 1`` * ``shape = 180, 360`` * ``ctype = 'GLON-AIT', 'GLAT-AIT'`` Parameters ---------- data : {'simulated', 'fermi'} Which dataset to use config : dict or None Configuration options Returns ------- dataset : ``ExampleDataset`` Example dataset object Examples -------- Make an example dataset: >>> from regions import make_example_dataset >>> config = dict(crpix=(18, 9), cdelt=(-10, 10), shape=(18, 36)) >>> dataset = make_example_dataset(data='simulated', config=config) Access properties of the ``dataset`` object: >>> dataset.source_table # doctest: +IGNORE_OUTPUT >>> dataset.event_table # doctest: +IGNORE_OUTPUT >>> dataset.wcs # doctest: +IGNORE_OUTPUT >>> dataset.image # doctest: +IGNORE_OUTPUT >>> dataset.hdu_list # doctest: +IGNORE_OUTPUT """ if data == 'simulated': return ExampleDatasetSimulated(config=config) elif data == 'fermi': return ExampleDatasetFermi(config=config) else: raise ValueError('Invalid selection data: {}'.format(data)) class ExampleDataset(object): """Base class for example dataset. """ def __init__(self, config=None): config_default = dict() # These parameters are FITS WCS order: (x, y) config_default['crval'] = 0, 0 config_default['crpix'] = 180, 90 config_default['cdelt'] = -1, 1 # This parameter is numpy order: (y, x) config_default['shape'] = 180, 360 config_default['ctype'] = 'GLON-AIT', 'GLAT-AIT' # Callers can update the default config parameters they want. if config: config_default.update(config) self.config = config_default @lazyproperty def wcs(self): """World coordinate system (`~astropy.wcs.WCS`).""" wcs = WCS(naxis=2) wcs.wcs.crval = self.config['crval'] wcs.wcs.crpix = self.config['crpix'] wcs.wcs.cdelt = self.config['cdelt'] wcs.wcs.ctype = self.config['ctype'] return wcs @lazyproperty def image(self): """Counts image (`~astropy.io.fits.ImageHDU`).""" events = self.event_table skycoord = SkyCoord(events['GLON'], events['GLAT'], unit='deg', frame='galactic') pixcoord = PixCoord.from_sky(skycoord=skycoord, wcs=self.wcs) shape = self.config['shape'] bins = [np.arange(shape[0] + 1), np.arange(shape[1] + 1)] sample = np.vstack((pixcoord.y, pixcoord.x)).T data, _ = np.histogramdd(sample=sample, bins=bins) data = data.astype('float32') header = self.wcs.to_header() return fits.ImageHDU(data=data, header=header, name='image') @lazyproperty def hdu_list(self): """HDU list (`~astropy.io.fits.HDUList`). Different pieces collected together in a HDU list. This method makes it easy to write the example dataset to a FITS file with multiple HDUs. """ hdu_list = fits.HDUList() hdu = _table_to_bintable(self.source_table) hdu.name = 'sources' hdu_list.append(hdu) hdu = _table_to_bintable(self.event_table) hdu.name = 'events' hdu_list.append(hdu) hdu = self.image hdu.name = 'image' hdu_list.append(hdu) return hdu_list class ExampleDatasetSimulated(ExampleDataset): """Example simulated dataset. Similar to `ExampleDatasetFermi`, but simulated, not requiring any data files. """ @lazyproperty def source_table(self): """Source table (`~astropy.table.Table`). Columns: GLON, GLAT, COUNTS """ table = Table() table['GLON'] = np.array([0, 45, 45], dtype='float32') table['GLAT'] = np.array([0, 0, 45], dtype='float32') table['COUNTS'] = np.array([100, 100, 100], dtype='int32') return table @lazyproperty def event_table(self): """Event table (`~astropy.table.Table`). Columns: GLON, GLAT, SOURCE_IDX """ # Create event list table for each source tables = [] for source in self.source_table: lon = source['GLON'] * np.ones(source['COUNTS']) lat = source['GLAT'] * np.ones(source['COUNTS']) coord = SkyCoord(lon, lat, unit='deg', frame='galactic') # TODO: scatter positions assuming Gaussian PSF on the sky # using SkyOffsetFrame. table = Table() table['GLON'] = lon table['GLAT'] = lat table['SOURCE_IDX'] = source.index tables.append(table) # Stack all tables together table = table_vstack(tables) return table class ExampleDatasetFermi(ExampleDataset): """Example real dataset using Fermi-LAT 2FHL source catalog and event list. When saving the HDU list to a FITS file, the file size is 748K, with the 65k EVENTS taking up most of the space. """ @lazyproperty def source_table(self): """Source table (`~astropy.table.Table`). Columns: GLON, GLAT, COUNTS """ url = 'https://github.com/gammapy/gammapy-extra/raw/master/datasets/fermi_2fhl/gll_psch_v08.fit.gz' table = Table.read(url, hdu='2FHL Source Catalog') table.rename_column('Npred', 'COUNTS') table.keep_columns(['GLON', 'GLAT', 'COUNTS']) table.meta.clear() return table @lazyproperty def event_table(self): """Event table (`~astropy.table.Table`). Columns: GLON, GLAT """ url = 'https://github.com/gammapy/gammapy-extra/raw/master/datasets/fermi_2fhl/2fhl_events.fits.gz' table = Table.read(url, hdu='EVENTS') table.rename_column('L', 'GLON') table.rename_column('B', 'GLAT') table.keep_columns(['GLON', 'GLAT']) table.meta.clear() return table def _table_to_bintable(table): """Convert `~astropy.table.Table` to `astropy.io.fits.BinTable`.""" data = table.as_array() header = fits.Header() header.update(table.meta) name = table.meta.pop('name', None) return fits.BinTableHDU(data, header, name=name) if __name__ == '__main__': dataset = make_example_dataset(data='simulated') dataset.hdu_list.writeto('example-dataset-simulated.fits', clobber=True) dataset = make_example_dataset(data='fermi') dataset.hdu_list.writeto('example-dataset-fermi.fits', clobber=True) regions-0.4/regions/_utils/tests/0000755000076600000240000000000013501657425017203 5ustar deilstaff00000000000000regions-0.4/regions/_utils/tests/__init__.py0000644000076600000240000000000013336761120021274 0ustar deilstaff00000000000000regions-0.4/regions/_utils/tests/test_examples.py0000644000076600000240000000253013477731541022436 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from numpy.testing import assert_allclose from ..examples import make_example_dataset class TestExampleSimulatedDataset: def setup(self): self.dataset = make_example_dataset(data='simulated') def test_source_table(self): source_table = self.dataset.source_table assert len(source_table) == 3 def test_event_table(self): # source_table = self.dataset.source_table event_table = self.dataset.event_table assert len(event_table) == 300 def test_wcs(self): wcs = self.dataset.wcs assert_allclose(wcs.wcs.crval, (0, 0)) assert_allclose(wcs.wcs.crpix, (180, 90)) assert_allclose(wcs.wcs.cdelt, (-1, 1)) assert wcs.wcs.ctype[0] == 'GLON-AIT' assert wcs.wcs.ctype[1] == 'GLAT-AIT' def test_image(self): image = self.dataset.image assert image.data.shape == (180, 360) assert np.nansum(image.data) == 300 def test_hdu_list(self): hdu_list = self.dataset.hdu_list # Check that all data is present assert hdu_list[1] == hdu_list['sources'] assert hdu_list[2] == hdu_list['events'] assert hdu_list[3] == hdu_list['image'] regions-0.4/regions/_utils/wcs_helpers.py0000644000076600000240000000626513477731541020746 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst # (taken from photutils: should probably migrate into astropy.wcs) from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from astropy import units as u from astropy.coordinates import UnitSphericalRepresentation from astropy.wcs.utils import skycoord_to_pixel from ..core.pixcoord import PixCoord skycoord_to_pixel_mode = 'all' def skycoord_to_pixel_scale_angle(skycoord, wcs, small_offset=1 * u.arcsec): """ Convert a set of SkyCoord coordinates into pixel coordinates, pixel scales, and position angles. Parameters ---------- skycoord : `~astropy.coordinates.SkyCoord` Sky coordinates wcs : `~astropy.wcs.WCS` The WCS transformation to use small_offset : `~astropy.units.Quantity` A small offset to use to compute the angle Returns ------- pixcoord : `~regions.PixCoord` Pixel coordinates scale : float The pixel scale at each location, in degrees/pixel angle : `~astropy.units.Quantity` The position angle of the celestial coordinate system in pixel space. """ # Convert to pixel coordinates x, y = skycoord_to_pixel(skycoord, wcs, mode=skycoord_to_pixel_mode) pixcoord = PixCoord(x=x, y=y) # We take a point directly 'above' (in latitude) the position requested # and convert it to pixel coordinates, then we use that to figure out the # scale and position angle of the coordinate system at the location of # the points. # Find the coordinates as a representation object r_old = skycoord.represent_as('unitspherical') # Add a a small perturbation in the latitude direction (since longitude # is more difficult because it is not directly an angle). dlat = small_offset r_new = UnitSphericalRepresentation(r_old.lon, r_old.lat + dlat) coords_offset = skycoord.realize_frame(r_new) # Find pixel coordinates of offset coordinates x_offset, y_offset = skycoord_to_pixel(coords_offset, wcs, mode=skycoord_to_pixel_mode) # Find vector dx = x_offset - x dy = y_offset - y # Find the length of the vector scale = np.hypot(dx, dy) / dlat.to('degree').value # Find the position angle angle = np.arctan2(dy, dx) * u.radian return pixcoord, scale, angle def assert_angle_or_pixel(name, q): """ Check that ``q`` is either an angular or a pixel `~astropy.units.Quantity`. """ if isinstance(q, u.Quantity): if q.unit.physical_type == 'angle' or q.unit is u.pixel: pass else: raise ValueError("{0} should have angular or pixel " "units".format(name)) else: raise TypeError("{0} should be a Quantity instance".format(name)) def assert_angle(name, q): """ Check that ``q`` is an angular `~astropy.units.Quantity`. """ if isinstance(q, u.Quantity): if q.unit.physical_type == 'angle': pass else: raise ValueError("{0} should have angular units".format(name)) else: raise TypeError("{0} should be a Quantity instance".format(name)) regions-0.4/regions/conftest.py0000644000076600000240000000571213477731541016752 0ustar deilstaff00000000000000# this contains imports plugins that configure py.test for astropy tests. # by importing them here in conftest.py they are discoverable by py.test # no matter how it is invoked within the source tree. from distutils.version import LooseVersion try: import pytest_arraydiff except ImportError: raise ImportError("The pytest-arraydiff package is required for the tests. " "You can install it with: pip install pytest-arraydiff") else: # We need to remove pytest_arraydiff from the namespace otherwise pytest # gets confused, because it tries to interpret pytest_* as a special # function name. del pytest_arraydiff from astropy.version import version as astropy_version if LooseVersion(astropy_version) < LooseVersion('2.0.3'): # Astropy is not compatible with the standalone plugins prior this while # astroquery requires them, so we need this workaround. This will mess # up the test header, but everything else will work. from astropy.tests.pytest_plugins import (PYTEST_HEADER_MODULES, TESTED_VERSIONS) elif astropy_version < '3.0': # With older versions of Astropy, we actually need to import the pytest # plugins themselves in order to make them discoverable by pytest. from astropy.tests.pytest_plugins import * else: # As of Astropy 3.0, the pytest plugins provided by Astropy are # automatically made available when Astropy is installed. This means it's # not necessary to import them here, but we still need to import global # variables that are used for configuration. from astropy.tests.plugins.display import PYTEST_HEADER_MODULES, TESTED_VERSIONS from astropy.tests.helper import enable_deprecations_as_exceptions # Uncomment the following line to treat all DeprecationWarnings as # exceptions # enable_deprecations_as_exceptions() # noqa # Uncomment and customize the following lines to add/remove entries from # the list of packages for which version numbers are displayed when running # the tests. Making it pass for KeyError is essential in some cases when # the package uses other astropy affiliated packages. try: PYTEST_HEADER_MODULES['Cython'] = 'Cython' # noqa PYTEST_HEADER_MODULES['Astropy'] = 'astropy' # noqa del PYTEST_HEADER_MODULES['h5py'] # noqa del PYTEST_HEADER_MODULES['Pandas'] # noqa except (NameError, KeyError): # NameError is needed to support Astropy < 1.0 pass # Uncomment the following lines to display the version number of the # package rather than the version number of Astropy in the top line when # running the tests. import os # This is to figure out the affiliated package version, rather than # using Astropy's try: from .version import version, astropy_helpers_version except ImportError: version = 'dev' packagename = os.path.basename(os.path.dirname(__file__)) TESTED_VERSIONS[packagename] = version # noqa TESTED_VERSIONS['astropy_helpers'] = astropy_helpers_version regions-0.4/regions/core/0000755000076600000240000000000013501657425015472 5ustar deilstaff00000000000000regions-0.4/regions/core/__init__.py0000644000076600000240000000036113336761120017575 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ Region core functionality. """ from .core import * from .pixcoord import * from .mask import * from .bounding_box import * from .compound import * from .attributes import * regions-0.4/regions/core/attributes.py0000644000076600000240000001327313501640150020223 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst import abc import six import weakref from astropy.coordinates import SkyCoord from astropy.units import Quantity import numpy as np from .pixcoord import PixCoord from .core import PixelRegion, SkyRegion __all__ = ['RegionMeta', 'RegionVisual'] """ Several custom descriptor classes are present here for attribute validation of region classes. Also, contains RegionMeta and RegionVisual classes to handle meta data of regions. """ @six.add_metaclass(abc.ABCMeta) class RegionAttr(object): """Descriptor base class""" def __init__(self, name): self.name = name def __get__(self, instance, owner): if instance is None: return self return instance.__dict__[self.name] def __set__(self, instance, value): self._validate(value) instance.__dict__[self.name] = value def __delete__(self, instance): del instance.__dict__[self.name] @abc.abstractmethod def _validate(self): pass class ScalarPix(RegionAttr): """ Descriptor class for `~regions.PixelRegion` which takes a scalar `~regions.PixCoord` object. """ def _validate(self, value): if not (isinstance(value, PixCoord) and value.isscalar): raise ValueError('The {} must be a 0D PixCoord object' .format(self.name)) class OneDPix(RegionAttr): """ Descriptor class for `~regions.PixelRegion` which takes a one dimensional `regions.PixCoord` object. """ def _validate(self, value): if not (isinstance(value, PixCoord) and not value.isscalar and value.x.ndim == 1): raise ValueError('The {} must be a 1D PixCoord object' .format(self.name)) class ScalarLength(RegionAttr): """ Descriptor class for `~regions.PixelRegion` which takes a scalar python/numpy number. """ def _validate(self, value): if not np.isscalar(value): raise ValueError( 'The {} must be a scalar numpy/python number'.format(self.name)) class ScalarSky(RegionAttr): """ Descriptor class for `~regions.SkyRegion` which takes a scalar `~astropy.coordinates.SkyCoord` object. """ def _validate(self, value): if not (isinstance(value, SkyCoord) and value.isscalar): raise ValueError('The {} must be a 0D SkyCoord object'. format(self.name)) class OneDSky(RegionAttr): """ Descriptor class for `~regions.SkyRegion` which takes a one dimensional `~astropy.coordinates.SkyCoord` object. """ def _validate(self, value): if not (isinstance(value, SkyCoord) and value.ndim == 1): raise ValueError('The {} must be a 1D SkyCoord object'. format(self.name)) class QuantityLength(RegionAttr): """ Descriptor class for `~regions.SkyRegion` which takes a scalar `~astropy.units.Quantity` object. """ def _validate(self, value): if not (isinstance(value, Quantity) and value.isscalar): raise ValueError('The {} must be a scalar astropy Quantity object' .format(self.name)) class CompoundRegionPix(RegionAttr): """ Descriptor class for `~regions.CompoundPixelRegion` which takes a `~regions.PixelRegion` object. """ def _validate(self, value): if not isinstance(value, PixelRegion): raise ValueError('The {} must be a PixelRegion object' .format(self.name)) class CompoundRegionSky(RegionAttr): """ Descriptor class is for `~regions.CompoundSkyRegion` which takes a `~regions.SkyRegion` object. """ def _validate(self, value): if not isinstance(value, SkyRegion): raise ValueError('The {} must be a SkyRegion object' .format(self.name)) @six.add_metaclass(abc.ABCMeta) class Meta(dict): def __init__(self, seq=None, **kwargs): super(Meta, self).__init__() if seq: if isinstance(seq, dict): for key, val in seq.items(): self.__setitem__(key, val) else: for key, val in seq: self.__setitem__(key, val) if len(kwargs) > 0: for key, val in kwargs.items(): self.__setitem__(key, val) def __setitem__(self, key, value): key = self.key_mapping.get(key, key) if key in self.valid_keys: super(Meta, self).__setitem__(key, value) else: raise KeyError( "{} is not a valid key for this class.".format(key)) def __getitem__(self, item): item = self.key_mapping.get(item, item) return super(Meta, self).__getitem__(item) class RegionMeta(Meta): """ A python dictionary subclass which holds the meta attributes of the region. """ valid_keys = ['label', 'include', 'frame', 'range', 'veltype', 'restfreq', 'tag', 'comment', 'line', 'name', 'select', 'highlite', 'fixed', 'edit', 'move', 'rotate', 'delete', 'source', 'background', 'corr', 'type', 'text' ] key_mapping = {} class RegionVisual(Meta): """ A python dictionary subclass which holds the visual attributes of the region. """ valid_keys = ['color', 'dash', 'font', 'dashlist', 'symsize', 'symthick', 'symbol', 'fontsize', 'fontstyle', 'usetex', 'labelpos', 'labeloff', 'linewidth', 'linestyle', 'fill', 'line', 'textangle', 'fontweight'] key_mapping = {'width': 'linewidth', 'point': 'symbol'} regions-0.4/regions/core/bounding_box.py0000644000076600000240000002417613501414013020513 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import (absolute_import, division, print_function, unicode_literals) import numpy as np from astropy.io.fits.util import _is_int __all__ = ['BoundingBox'] class BoundingBox(object): """ A rectangular bounding box in integer (not float) pixel indices. Parameters ---------- ixmin, ixmax, iymin, iymax : int The bounding box pixel indices. Note that the upper values (``iymax`` and ``ixmax``) are exclusive as for normal slices in Python. The lower values (``ixmin`` and ``iymin``) must not be greater than the respective upper values (``ixmax`` and ``iymax``). Examples -------- >>> from regions import BoundingBox >>> # constructing a BoundingBox like this is cryptic: >>> bbox = BoundingBox(1, 10, 2, 20) >>> # it's better to use keyword arguments for readability: >>> bbox = BoundingBox(ixmin=1, ixmax=10, iymin=2, iymax=20) >>> bbox # nice repr, useful for interactive work BoundingBox(ixmin=1, ixmax=10, iymin=2, iymax=20) >>> # sometimes it's useful to check if two bounding boxes are the same >>> bbox == BoundingBox(ixmin=1, ixmax=10, iymin=2, iymax=20) True >>> bbox == BoundingBox(ixmin=7, ixmax=10, iymin=2, iymax=20) False >>> # "shape" and "slices" can be useful when working with numpy arrays >>> bbox.shape # numpy order: (y, x) (18, 9) >>> bbox.slices # numpy order: (y, x) (slice(2, 20, None), slice(1, 10, None)) >>> # "extent" is useful when plotting the BoundingBox with matplotlib >>> bbox.extent # matplotlib order: (x, y) (0.5, 9.5, 1.5, 19.5) """ def __init__(self, ixmin, ixmax, iymin, iymax): if not _is_int(ixmin): raise TypeError('ixmin must be an integer') if not _is_int(ixmax): raise TypeError('ixmax must be an integer') if not _is_int(iymin): raise TypeError('iymin must be an integer') if not _is_int(iymax): raise TypeError('iymax must be an integer') if ixmin > ixmax: raise ValueError('ixmin must be <= ixmax') if iymin > iymax: raise ValueError('iymin must be <= iymax') self.ixmin = ixmin self.ixmax = ixmax self.iymin = iymin self.iymax = iymax @classmethod def from_float(cls, xmin, xmax, ymin, ymax): """ Return the smallest bounding box that fully contains a given rectangle defined by float coordinate values. Following the pixel index convention, an integer index corresponds to the center of a pixel and the pixel edges span from (index - 0.5) to (index + 0.5). For example, the pixel edge spans of the following pixels are: - pixel 0: from -0.5 to 0.5 - pixel 1: from 0.5 to 1.5 - pixel 2: from 1.5 to 2.5 In addition, because `BoundingBox` upper limits are exclusive (by definition), 1 is added to the upper pixel edges. See examples below. Parameters ---------- xmin, xmax, ymin, ymax : float Float coordinates defining a rectangle. The lower values (``xmin`` and ``ymin``) must not be greater than the respective upper values (``xmax`` and ``ymax``). Returns ------- bbox : `BoundingBox` object The minimal ``BoundingBox`` object fully containing the input rectangle coordinates. Examples -------- >>> from regions import BoundingBox >>> BoundingBox.from_float(xmin=1.0, xmax=10.0, ymin=2.0, ymax=20.0) BoundingBox(ixmin=1, ixmax=11, iymin=2, iymax=21) >>> BoundingBox.from_float(xmin=1.4, xmax=10.4, ymin=1.6, ymax=10.6) BoundingBox(ixmin=1, ixmax=11, iymin=2, iymax=12) """ ixmin = int(np.floor(xmin + 0.5)) ixmax = int(np.ceil(xmax + 0.5)) iymin = int(np.floor(ymin + 0.5)) iymax = int(np.ceil(ymax + 0.5)) return cls(ixmin, ixmax, iymin, iymax) def __eq__(self, other): if not isinstance(other, BoundingBox): raise TypeError('Can compare BoundingBox only to another ' 'BoundingBox.') return ( (self.ixmin == other.ixmin) and (self.ixmax == other.ixmax) and (self.iymin == other.iymin) and (self.iymax == other.iymax) ) def __or__(self, other): return self.union(other) def __and__(self, other): return self.intersection(other) def __repr__(self): data = self.__dict__ data['name'] = self.__class__.__name__ fmt = ('{name}(ixmin={ixmin}, ixmax={ixmax}, iymin={iymin}, ' 'iymax={iymax})') return fmt.format(**data) @property def shape(self): """ The ``(ny, nx)`` shape of the bounding box. """ return self.iymax - self.iymin, self.ixmax - self.ixmin @property def slices(self): """ The bounding box as a tuple of `slice` objects. The slice tuple is in numpy axis order (i.e. ``(y, x)``) and therefore can be used to slice numpy arrays. """ return (slice(self.iymin, self.iymax), slice(self.ixmin, self.ixmax)) @property def extent(self): """ The extent of the mask, defined as the ``(xmin, xmax, ymin, ymax)`` bounding box from the bottom-left corner of the lower-left pixel to the upper-right corner of the upper-right pixel. The upper edges here are the actual pixel positions of the edges, i.e. they are not "exclusive" indices used for python indexing. This is useful for plotting the bounding box using Matplotlib. """ return ( self.ixmin - 0.5, self.ixmax - 0.5, self.iymin - 0.5, self.iymax - 0.5, ) def as_artist(self, **kwargs): """ Return a `matplotlib.patches.Rectangle` that represents the bounding box. Parameters ---------- kwargs : `dict` Any keyword arguments accepted by `matplotlib.patches.Patch`. Returns ------- result : `matplotlib.patches.Rectangle` A matplotlib rectangular patch. Examples -------- .. plot:: :include-source: import matplotlib.pyplot as plt from regions import BoundingBox bbox = BoundingBox(2, 7, 3, 8) fig = plt.figure() ax = fig.add_subplot(1, 1, 1) np.random.seed(12345) ax.imshow(np.random.random((10, 10)), interpolation='nearest', cmap='viridis') ax.add_patch(bbox.as_artist(facecolor='none', edgecolor='white', lw=2.)) """ from matplotlib.patches import Rectangle return Rectangle(xy=(self.extent[0], self.extent[2]), width=self.shape[1], height=self.shape[0], **kwargs) def to_region(self): """ Return a `~regions.RectanglePixelRegion` that represents the bounding box. """ from ..shapes import RectanglePixelRegion from .pixcoord import PixCoord xpos = (self.extent[1] + self.extent[0]) / 2. ypos = (self.extent[3] + self.extent[2]) / 2. xypos = PixCoord(xpos, ypos) h, w = self.shape return RectanglePixelRegion(center=xypos, width=w, height=h) def plot(self, origin=(0, 0), ax=None, **kwargs): """ Plot the `BoundingBox` on a matplotlib `~matplotlib.axes.Axes` instance. Parameters ---------- origin : array_like, optional The ``(x, y)`` position of the origin of the displayed image. ax : `matplotlib.axes.Axes` instance, optional If `None`, then the current `~matplotlib.axes.Axes` instance is used. kwargs : `dict` Any keyword arguments accepted by `matplotlib.patches.Patch`. Returns ------- ax : `~matplotlib.axes.Axes` Axes on which the patch is added. """ reg = self.to_region() return reg.plot(origin=origin, ax=ax, **kwargs) def union(self, other): """ Return a `BoundingBox` representing the union of this `BoundingBox` with another `BoundingBox`. Parameters ---------- other : `~photutils.BoundingBox` The `BoundingBox` to join with this one. Returns ------- result : `~photutils.BoundingBox` A `BoundingBox` representing the union of the input `BoundingBox` with this one. """ if not isinstance(other, BoundingBox): raise TypeError('BoundingBox can be joined only with another ' 'BoundingBox.') ixmin = min((self.ixmin, other.ixmin)) ixmax = max((self.ixmax, other.ixmax)) iymin = min((self.iymin, other.iymin)) iymax = max((self.iymax, other.iymax)) return BoundingBox(ixmin=ixmin, ixmax=ixmax, iymin=iymin, iymax=iymax) def intersection(self, other): """ Return a `BoundingBox` representing the intersection of this `BoundingBox` with another `BoundingBox`. Parameters ---------- other : `~photutils.BoundingBox` The `BoundingBox` to intersect with this one. Returns ------- result : `~photutils.BoundingBox` A `BoundingBox` representing the intersection of the input `BoundingBox` with this one. """ if not isinstance(other, BoundingBox): raise TypeError('BoundingBox can be intersected only with ' 'another BoundingBox.') ixmin = max(self.ixmin, other.ixmin) ixmax = min(self.ixmax, other.ixmax) iymin = max(self.iymin, other.iymin) iymax = min(self.iymax, other.iymax) if ixmax < ixmin or iymax < iymin: return None return BoundingBox(ixmin=ixmin, ixmax=ixmax, iymin=iymin, iymax=iymax) regions-0.4/regions/core/compound.py0000644000076600000240000002025413501650710017661 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import operator as op import numpy as np from . import PixelRegion, SkyRegion, BoundingBox, RegionMask from ..core.attributes import (CompoundRegionPix, CompoundRegionSky, RegionMeta, RegionVisual) __all__ = ['CompoundPixelRegion', 'CompoundSkyRegion'] class CompoundPixelRegion(PixelRegion): """ Represents the logical combination of two regions in pixel coordinates. Parameters ---------- region1 : `~regions.PixelRegion` object The inner Pixel region. region2 : `~regions.PixelRegion` object The outer Pixel region. operator : `function` A callable binary operator. meta : `~regions.RegionMeta` object, optional A dictionary which stores the meta attributes of this region. visual : `~regions.RegionVisual` object, optional A dictionary which stores the visual meta attributes of this region. """ region1 = CompoundRegionPix('region1') region2 = CompoundRegionPix('region2') def __init__(self, region1, region2, operator, meta=None, visual=None): if not callable(operator): raise TypeError("operator must be callable") self.region1 = region1 self.region2 = region2 if meta is None: self.meta = region1.meta else: self.meta = RegionMeta() if visual is None: self.visual = region1.visual else: self.visual = RegionVisual() self._operator = operator self._repr_params = ('region1', 'region2', 'operator') @property def operator(self): return self._operator def contains(self, pixcoord): in_reg = self.operator(self.region1.contains(pixcoord), self.region2.contains(pixcoord)) if self.meta.get('include', True): return in_reg else: return np.logical_not(in_reg) def to_mask(self, mode='center', subpixels=1): if mode != 'center': raise NotImplementedError mask1 = self.region1.to_mask(mode=mode, subpixels=subpixels) mask2 = self.region2.to_mask(mode=mode, subpixels=subpixels) # Common bounding box bbox = BoundingBox( ixmin=min(mask1.bbox.ixmin, mask2.bbox.ixmin), ixmax=max(mask1.bbox.ixmax, mask2.bbox.ixmax), iymin=min(mask1.bbox.iymin, mask2.bbox.iymin), iymax=max(mask1.bbox.iymax, mask2.bbox.iymax) ) # Pad mask1.data and mask2.data to get the same shape padded_data = list() for mask in (mask1, mask2): pleft = abs(mask.bbox.ixmin - bbox.ixmin) pright = abs(bbox.ixmax - mask.bbox.ixmax) ptop = abs(bbox.iymax - mask.bbox.iymax) pbottom = abs(mask.bbox.iymin - bbox.iymin) padded_data.append(np.pad(mask.data, ((ptop, pbottom), (pleft, pright)), 'constant')) data = self.operator(*np.array(padded_data, dtype=np.int)) return RegionMask(data=data, bbox=bbox) def to_sky(self, wcs): skyreg1 = self.region1.to_sky(wcs=wcs) skyreg2 = self.region2.to_sky(wcs=wcs) return CompoundSkyRegion(region1=skyreg1, operator=self.operator, region2=skyreg2, meta=self.meta, visual=self.visual) @staticmethod def _make_annulus_path(patch_inner, patch_outer): """ Defines a matplotlib annulus path from two patches. This preserves the cubic Bezier curves (CURVE4) of the aperture paths. # This is borrowed from photutils aperture. """ import matplotlib.path as mpath path_inner = patch_inner.get_path() transform_inner = patch_inner.get_transform() path_inner = transform_inner.transform_path(path_inner) path_outer = patch_outer.get_path() transform_outer = patch_outer.get_transform() path_outer = transform_outer.transform_path(path_outer) verts_inner = path_inner.vertices[:-1][::-1] verts_inner = np.concatenate((verts_inner, [verts_inner[-1]])) verts = np.vstack((path_outer.vertices, verts_inner)) codes = np.hstack((path_outer.codes, path_inner.codes)) return mpath.Path(verts, codes) def as_artist(self, origin=(0, 0), **kwargs): """ Matplotlib patch object for annulus region (`matplotlib.patches.PathPatch`). Parameters ---------- origin : array_like, optional The ``(x, y)`` pixel position of the origin of the displayed image. Default is (0, 0). kwargs : `dict` All keywords that a `~matplotlib.patches.PathPatch` object accepts Returns ------- patch : `~matplotlib.patches.PathPatch` Matplotlib patch object """ if self.region1.center == self.region2.center and self.operator == op.xor: import matplotlib.patches as mpatches patch_inner = self.region1.as_artist(origin=origin) patch_outer = self.region2.as_artist(origin=origin) path = self._make_annulus_path(patch_inner, patch_outer) patch = mpatches.PathPatch(path, **kwargs) return patch else: raise NotImplementedError def bounding_box(self, **kwargs): raise NotImplementedError @property def area(self): raise NotImplementedError def rotate(self, center, angle): """Make a rotated region. Rotates counter-clockwise for positive ``angle``. Parameters ---------- center : `PixCoord` Rotation center point angle : `~astropy.coordinates.Angle` Rotation angle Returns ------- region : `CompoundPixelRegion` Rotated region (an independent copy) """ region1 = self.region1.rotate(center, angle) region2 = self.region2.rotate(center, angle) return self.copy(region1=region1, region2=region2) class CompoundSkyRegion(SkyRegion): """ Represents the logical combination of two regions in sky coordinates. Parameters ---------- region1 : `~regions.SkyRegion` object The inner sky region. region2 : `~regions.SkyRegion` object The outer sky region. operator : `function` A callable binary operator. meta : `~regions.RegionMeta` object, optional A dictionary which stores the meta attributes of this region. visual : `~regions.RegionVisual` object, optional A dictionary which stores the visual meta attributes of this region. """ region1 = CompoundRegionSky('region1') region2 = CompoundRegionSky('region2') def __init__(self, region1, region2, operator, meta=None, visual=None): if not callable(operator): raise TypeError("operator must be callable") self.region1 = region1 self.region2 = region2 if meta is None: self.meta = region1.meta else: self.meta = RegionMeta() if visual is None: self.visual = region1.visual else: self.visual = RegionVisual() self._operator = operator self._repr_params = ('region1', 'region2', 'operator') @property def operator(self): return self._operator def contains(self, skycoord, wcs): in_reg = self.operator(self.region1.contains(skycoord, wcs), self.region2.contains(skycoord, wcs)) if self.meta.get('include', True): return in_reg else: return np.logical_not(in_reg) def to_pixel(self, wcs): pixreg1 = self.region1.to_pixel(wcs=wcs) pixreg2 = self.region2.to_pixel(wcs=wcs) return CompoundPixelRegion(region1=pixreg1, operator=self.operator, region2=pixreg2, meta=self.meta, visual=self.visual) def as_artist(self, ax, **kwargs): raise NotImplementedError regions-0.4/regions/core/core.py0000644000076600000240000003133713501646477017010 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import (absolute_import, division, print_function, unicode_literals) import abc import six import copy import operator import inspect __all__ = ['Region', 'PixelRegion', 'SkyRegion'] """ Here we define global variables for the default `origin` and `mode` used for WCS transformations throughout the `regions` package. Their purpose is to simplify achieving uniformity across the codebase. They are mainly used as default arguments for methods that do WCS transformations. They are private (with an underscore), not part of the public API, users should not touch them. """ _DEFAULT_WCS_ORIGIN = 0 _DEFAULT_WCS_MODE = 'all' VALID_MASK_MODES = {'center', 'exact', 'subpixels'} class MetaRegion(abc.ABCMeta): """ This is a sub metaclass of `abc.ABCMeta` that makes methods of a class automatically have their docstrings filled in from the methods they override in the base class. If the class uses multiple inheritance, the docstring will be chosen from the first class in the bases list, in the same way as methods are normally resolved in Python. If this results in selecting the wrong docstring, the docstring will need to be explicitly included on the method. """ def __init__(cls, name, bases, dct): def is_public_member(key): return ( (key.startswith('__') and key.endswith('__') and len(key) > 4) or not key.startswith('_')) for key, val in six.iteritems(dct): if (inspect.isfunction(val) and is_public_member(key) and val.__doc__ is None): for base in cls.__mro__[1:]: super_method = getattr(base, key, None) if super_method is not None: val.__doc__ = super_method.__doc__ break super(MetaRegion, cls).__init__(name, bases, dct) @six.add_metaclass(MetaRegion) class Region(object): """ Base class for all regions. """ def copy(self, **changes): """Make an independent (deep) copy.""" fields = [] if hasattr(self, "center"): fields.append("center") if hasattr(self, "vertices"): fields.append("vertices") fields.extend(self._repr_params) fields.extend(["meta", "visual"]) for field in fields: if field not in changes: changes[field] = copy.deepcopy(getattr(self, field)) return self.__class__(**changes) def __repr__(self): if hasattr(self, 'center'): params = [repr(self.center)] else: params = [] if self._repr_params is not None: for key in self._repr_params: params.append('{0}={1}'.format(key.replace("_", " "), getattr(self, key))) params = ', '.join(params) return '<{0}({1})>'.format(self.__class__.__name__, params) def __str__(self): cls_info = [('Region', self.__class__.__name__)] if hasattr(self, 'center'): cls_info.append(('center', self.center)) if self._repr_params is not None: params_value = [(x.replace("_", " "), getattr(self, x)) for x in self._repr_params] cls_info += params_value fmt = ['{0}: {1}'.format(key, val) for key, val in cls_info] return '\n'.join(fmt) @abc.abstractmethod def intersection(self, other): """ Returns a region representing the intersection of this region with ``other``. """ raise NotImplementedError @abc.abstractmethod def symmetric_difference(self, other): """ Returns the union of the two regions minus any areas contained in the intersection of the two regions. """ raise NotImplementedError @abc.abstractmethod def union(self, other): """ Returns a region representing the union of this region with ``other``. """ raise NotImplementedError def __and__(self, other): return self.intersection(other) def __or__(self, other): return self.union(other) def __xor__(self, other): return self.symmetric_difference(other) class PixelRegion(Region): """ Base class for all regions defined in pixel coordinates """ def intersection(self, other): """ Returns a region representing the intersection of this region with ``other``. """ from .compound import CompoundPixelRegion return CompoundPixelRegion(region1=self, region2=other, operator=operator.and_) def symmetric_difference(self, other): """ Returns the union of the two regions minus any areas contained in the intersection of the two regions. """ from .compound import CompoundPixelRegion return CompoundPixelRegion(region1=self, region2=other, operator=operator.xor) def union(self, other): """ Returns a region representing the union of this region with ``other``. """ from .compound import CompoundPixelRegion return CompoundPixelRegion(region1=self, region2=other, operator=operator.or_) @abc.abstractmethod def contains(self, pixcoord): """ Checks whether a position or positions fall inside the region. Parameters ---------- pixcoord : `~regions.PixCoord` The position or positions to check. """ raise NotImplementedError def __contains__(self, coord): if not coord.isscalar: raise ValueError('coord must be scalar. coord={}'.format(coord)) return self.contains(coord) @abc.abstractmethod def to_sky(self, wcs): """ Returns a region defined in sky coordinates. Parameters ---------- wcs : `~astropy.wcs.WCS` instance The world coordinate system transformation to assume Returns ------- sky_region : `~regions.SkyRegion` object. """ raise NotImplementedError @abc.abstractproperty def bounding_box(self): """ The minimal bounding box (in integer pixel coordinates) that contains the region. """ raise NotImplementedError @abc.abstractmethod def to_mask(self, mode='center', subpixels=5): """ Returns a mask for the aperture. Parameters ---------- mode : { 'center' | 'exact' | 'subpixels'}, optional The following modes are available: * ``'center'``: returns 1 for pixels where the center is in the region, and 0 otherwise. * ``'exact'``: returns a value between 0 and 1 giving the fractional level of overlap of the pixel with the region. * ``'subpixels'``: A pixel is divided into subpixels and the center of each subpixel is tested (a subpixel is either completely in or out of the region). Returns a value between 0 and 1 giving the fractional level of overlap of the subpixels with the region. With ``subpixels`` set to 1, this method is equivalent to ``'center'``. subpixels : int, optional For the ``'subpixel'`` mode, resample pixels by this factor in each dimension. That is, each pixel is divided into ``subpixels ** 2`` subpixels. Returns ------- mask : `~regions.Mask` A region mask object. """ raise NotImplementedError @staticmethod def _validate_mode(mode, subpixels): if mode not in VALID_MASK_MODES: raise ValueError("Invalid mask mode: {0} (should be one " "of {1})".format(mode, '/'.join(VALID_MASK_MODES))) if mode == 'subpixels': if not isinstance(subpixels, int) or subpixels <= 0: raise ValueError("Invalid subpixels value: {0} (should be" " a strictly positive integer)".format(subpixels)) @abc.abstractmethod def as_artist(self, origin=(0, 0), **kwargs): """ Convert to mpl patch Parameters ---------- origin : array_like, optional The ``(x, y)`` pixel position of the origin of the displayed image. Default is (0, 0). kwargs : `dict` keywords that a `~matplotlib.patches.Patch` accepts Returns ------- patch : `~matplotlib.patches.Patch` Matplotlib patch """ raise NotImplementedError def mpl_properties_default(self, shape='patch'): """ This sets the default values of the visual attributes as specified under DS9 convention. """ kwargs = dict() kwargs['color'] = self.visual.get('color', 'green') kwargs['label'] = self.meta.get('label', "") if shape == 'text': kwargs['family'] = self.visual.get('font', 'helvetica') kwargs['rotation'] = self.visual.get('textangle', '0') kwargs['size'] = self.visual.get('fontsize', '12') kwargs['style'] = self.visual.get('fontsyle', 'normal') kwargs['weight'] = self.visual.get('fontweight', 'roman') else: if shape == 'Line2D': kwargs['marker'] = self.visual.get('symbol', 'o') kwargs['markersize'] = self.visual.get('symsize', 11) kwargs['markeredgecolor'] = kwargs['color'] kwargs['markeredgewidth'] = self.visual.get('width', 1) if shape == 'patch': kwargs['edgecolor'] = kwargs.pop('color') kwargs['fill'] = self.visual.get('fill', False) kwargs['linewidth'] = self.visual.get('linewidth', 1) kwargs['linestyle'] = self.visual.get('linstyle', 'solid') return kwargs def plot(self, origin=(0, 0), ax=None, **kwargs): """ Calls ``as_artist`` method forwarding all kwargs and adds patch to given axis. Parameters ---------- origin : array_like, optional The ``(x, y)`` pixel position of the origin of the displayed image. Default is (0, 0). ax : `~matplotlib.axes.Axes`, optional Axis kwargs : `dict` keywords that a `~matplotlib.patches.Patch` accepts Returns ------- ax : `~matplotlib.axes.Axes` Axes on which the patch is added. """ import matplotlib.pyplot as plt if ax is None: ax = plt.gca() artist = self.as_artist(origin=origin, **kwargs) ax.add_artist(artist) return ax class SkyRegion(Region): """ Base class for all regions defined in celestial coordinates """ def intersection(self, other): """ Returns a region representing the intersection of this region with ``other``. """ from .compound import CompoundSkyRegion return CompoundSkyRegion(region1=self, region2=other, operator=operator.and_) def symmetric_difference(self, other): """ Returns the union of the two regions minus any areas contained in the intersection of the two regions. """ from .compound import CompoundSkyRegion return CompoundSkyRegion(region1=self, region2=other, operator=operator.xor) def union(self, other): """ Returns a region representing the union of this region with ``other``. """ from .compound import CompoundSkyRegion return CompoundSkyRegion(region1=self, region2=other, operator=operator.or_) def contains(self, skycoord, wcs): """ Check whether a sky coordinate falls inside the region Parameters ---------- skycoord : `~astropy.coordinates.SkyCoord` The position or positions to check wcs : `~astropy.wcs.WCS` instance The world coordinate system transformation to assume """ from .pixcoord import PixCoord pixel_region = self.to_pixel(wcs) pixcoord = PixCoord.from_sky(skycoord, wcs) return pixel_region.contains(pixcoord) @abc.abstractmethod def to_pixel(self, wcs): """ Returns the equivalent region defined in pixel coordinates. Parameters ---------- wcs : `~astropy.wcs.WCS` instance The world coordinate system transformation to assume Returns ------- pixel_region : `~regions.PixelRegion` object. """ raise NotImplementedError regions-0.4/regions/core/mask.py0000644000076600000240000002031213501414013016755 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import (absolute_import, division, print_function, unicode_literals) import numpy as np import astropy.units as u __all__ = ['RegionMask'] class RegionMask(object): """ Class for a region mask. Parameters ---------- data : array_like A 2D array of a region mask representing the fractional overlap of the region on the pixel grid. This should be the full-sized (i.e. not truncated) array that is the direct output of one of the low-level "geometry" functions. bbox : `regions.BoundingBox` The bounding box for the region. Examples -------- Usage examples are provided in the :ref:`gs-masks` section of the docs. """ def __init__(self, data, bbox): self.data = np.asanyarray(data) if self.data.shape != bbox.shape: raise ValueError('data and bounding box must have the same ' 'shape.') self.bbox = bbox self._mask = (self.data == 0) def __array__(self): """ Array representation of the mask data array (e.g., for matplotlib). """ return self.data @property def shape(self): """ The shape of the mask data array. """ return self.data.shape def _overlap_slices(self, shape): """ Calculate the slices for the overlapping part of the bounding box and an array of the given shape. Parameters ---------- shape : tuple of int The ``(ny, nx)`` shape of array where the slices are to be applied. Returns ------- slices_large : tuple of slices A tuple of slice objects for each axis of the large array, such that ``large_array[slices_large]`` extracts the region of the large array that overlaps with the small array. slices_small : slice A tuple of slice objects for each axis of the small array, such that ``small_array[slices_small]`` extracts the region of the small array that is inside the large array. """ if len(shape) != 2: raise ValueError('input shape must have 2 elements.') xmin = self.bbox.ixmin xmax = self.bbox.ixmax ymin = self.bbox.iymin ymax = self.bbox.iymax if xmin >= shape[1] or ymin >= shape[0] or xmax <= 0 or ymax <= 0: # no overlap of the region with the data return None, None slices_large = (slice(max(ymin, 0), min(ymax, shape[0])), slice(max(xmin, 0), min(xmax, shape[1]))) slices_small = (slice(max(-ymin, 0), min(ymax - ymin, shape[0] - ymin)), slice(max(-xmin, 0), min(xmax - xmin, shape[1] - xmin))) return slices_large, slices_small def _to_image_partial_overlap(self, image): """ Return an image of the mask in a 2D array, where the mask is not fully within the image (i.e. partial or no overlap). """ # find the overlap of the mask on the output image shape slices_large, slices_small = self._overlap_slices(image.shape) if slices_small is None: return None # no overlap # insert the mask into the output image image[slices_large] = self.data[slices_small] return image def to_image(self, shape): """ Return an image of the mask in a 2D array of the given shape, taking any edge effects into account. Parameters ---------- shape : tuple of int The ``(ny, nx)`` shape of the output array. Returns ------- result : `~numpy.ndarray` A 2D array of the mask. """ if len(shape) != 2: raise ValueError('input shape must have 2 elements.') image = np.zeros(shape) if self.bbox.ixmin < 0 or self.bbox.iymin < 0: return self._to_image_partial_overlap(image) try: image[self.bbox.slices] = self.data except ValueError: # partial or no overlap image = self._to_image_partial_overlap(image) return image def cutout(self, data, fill_value=0., copy=False): """ Create a cutout from the input data over the mask bounding box, taking any edge effects into account. Parameters ---------- data : array_like A 2D array on which to apply the region mask. fill_value : float, optional The value used to fill pixels where the region mask does not overlap with the input ``data``. The default is 0. copy : bool, optional If `True` then the returned cutout array will always be hold a copy of the input ``data``. If `False` and the mask is fully within the input ``data``, then the returned cutout array will be a view into the input ``data``. In cases where the mask partially overlaps or has no overlap with the input ``data``, the returned cutout array will always hold a copy of the input ``data`` (i.e. this keyword has no effect). Returns ------- result : `~numpy.ndarray` or `None` A 2D array cut out from the input ``data`` representing the same cutout region as the region mask. If there is a partial overlap of the region mask with the input data, pixels outside of the data will be assigned to ``fill_value``. `None` is returned if there is no overlap of the region with the input ``data``. """ data = np.asanyarray(data) if data.ndim != 2: raise ValueError('data must be a 2D array.') partial_overlap = False if self.bbox.ixmin < 0 or self.bbox.iymin < 0: partial_overlap = True if not partial_overlap: # try this for speed -- the result may still be a partial # overlap, in which case the next block will be triggered if copy: cutout = np.copy(data[self.bbox.slices]) else: cutout = data[self.bbox.slices] if partial_overlap or (cutout.shape != self.shape): slices_large, slices_small = self._overlap_slices(data.shape) if slices_small is None: return None # no overlap # cutout is a copy cutout = np.zeros(self.shape, dtype=data.dtype) cutout[:] = fill_value cutout[slices_small] = data[slices_large] if isinstance(data, u.Quantity): cutout = u.Quantity(cutout, unit=data.unit) return cutout def multiply(self, data, fill_value=0.): """ Multiply the region mask with the input data, taking any edge effects into account. The result is a mask-weighted cutout from the data. Parameters ---------- data : array_like or `~astropy.units.Quantity` The 2D array to multiply with the region mask. fill_value : float, optional The value is used to fill pixels where the region mask does not overlap with the input ``data``. The default is 0. Returns ------- result : `~numpy.ndarray` or `None` A 2D mask-weighted cutout from the input ``data``. If there is a partial overlap of the region mask with the input data, pixels outside of the data will be assigned to ``fill_value`` before being multipled with the mask. `None` is returned if there is no overlap of the region with the input ``data``. """ cutout = self.cutout(data, fill_value=fill_value) if cutout is None: return None else: weighted_cutout = cutout * self.data # needed to zero out non-finite data values outside of the # mask but within the bounding box weighted_cutout[self._mask] = 0.0 return weighted_cutout regions-0.4/regions/core/pixcoord.py0000644000076600000240000001351713501414017017666 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import copy import numpy as np from astropy.coordinates import SkyCoord from .core import _DEFAULT_WCS_ORIGIN, _DEFAULT_WCS_MODE __all__ = ['PixCoord'] class PixCoord(object): """Pixel coordinates. This class can represent scalar or array pixel coordinates. The data members are either numbers or Numpy arrays (not `~astropy.units.Quantity` objects with unit "pixel"). Given a `astropy.wcs.WCS` object, it can be transformed to and from a `~astropy.coordinates.SkyCoord` object. Parameters ---------- x : float or array-like Pixel coordinate x value y : float or array-like Pixel coordinate y value Examples -------- Usage examples are provided in the :ref:`gs-coord` section of the docs. """ def __init__(self, x, y): x, y = np.broadcast_arrays(x, y) if x.shape == (): self.x, self.y = x.item(), y.item() else: self.x, self.y = x, y def copy(self): return self.__class__( copy.deepcopy(self.x), copy.deepcopy(self.y), ) @staticmethod def _validate(val, name, expected='any'): """Validate that a given object is an appropriate `PixCoord`. This is used for input validation throughout the regions package, especially in the `__init__` method of pixel region classes. Parameters ---------- val : `PixCoord` The object to check name : str Parameter name (used for error messages) expected : {'any', 'scalar', 'not scalar'} What kind of PixCoord to check for Returns ------- val : `PixCoord` The input object (at the moment unmodified, might do fix-ups here later) """ if not isinstance(val, PixCoord): raise TypeError('{} must be a PixCoord'.format(name)) if expected == 'any': pass elif expected == 'scalar': if not val.isscalar: raise ValueError('{} must be a scalar PixCoord'.format(name)) elif expected == 'not scalar': if val.isscalar: raise ValueError('{} must be a non-scalar PixCoord'.format(name)) else: raise ValueError('Invalid argument for `expected`: {}'.format(expected)) return val @property def isscalar(self): return np.isscalar(self.x) def __repr__(self): data = dict(name=self.__class__.__name__, x=self.x, y=self.y) fmt = '{name}(x={x}, y={y})' return fmt.format(**data) def __len__(self): """Define len(pixcoord) for array-valued pixcoord""" return len(self.x) def __iter__(self): """Allows iteration for array-valued pixcoord Yields scalar `PixCoord` objects. """ for (x, y) in zip(self.x, self.y): yield PixCoord(x=x, y=y) def __getitem__(self, key): """Define indexing and slicing.""" if self.isscalar: raise IndexError('Scalar PixCoord cannot be indexed or sliced.') # Let Numpy do the slicing x = self.x[key] y = self.y[key] return PixCoord(x=x, y=y) def __eq__(self, other): """ It checks whether ``other`` is `PixCoord` object and whether their abscissa and ordinate values are equal using ``np.assert_allclose`` with their default tolerance values. """ if isinstance(other, PixCoord): return np.allclose([self.x, self.y], [other.x, other.y]) else: return False def to_sky(self, wcs, origin=_DEFAULT_WCS_ORIGIN, mode=_DEFAULT_WCS_MODE): """Convert this `PixCoord` to `~astropy.coordinates.SkyCoord`. Calls :meth:`astropy.coordinates.SkyCoord.from_pixel`. See parameter description there. """ return SkyCoord.from_pixel( xp=self.x, yp=self.y, wcs=wcs, origin=origin, mode=mode, ) @classmethod def from_sky(cls, skycoord, wcs, origin=_DEFAULT_WCS_ORIGIN, mode=_DEFAULT_WCS_MODE): """Create `PixCoord` from `~astropy.coordinates.SkyCoord`. Calls :meth:`astropy.coordinates.SkyCoord.to_pixel`. See parameter description there. """ x, y = skycoord.to_pixel(wcs=wcs, origin=origin, mode=mode) return cls(x=x, y=y) def separation(self, other): r"""Separation to another pixel coordinate. This is the two-dimensional cartesian separation :math:`d` with .. math:: d = \sqrt{(x_1 - x_2) ^ 2 + (y_1 - y_2) ^ 2} Parameters ---------- other : `PixCoord` Other pixel coordinate Returns ------- separation : `numpy.array` Separation in pixels """ dx = other.x - self.x dy = other.y - self.y return np.hypot(dx, dy) @property def xy(self): """ A 2-tuple ``(x, y)`` for this coordinate. """ return (self.x, self.y) def rotate(self, center, angle): """Make a rotated pixel coordinate. Rotates counter-clockwise for positive ``angle``. Parameters ---------- center : PixCoord Rotation center point angle : Angle Rotation angle Returns ------- coord : PixCoord Rotated coordinates (an independent copy) """ dx = self.x - center.x dy = self.y - center.y vec = np.array([dx, dy]) c, s = np.cos(angle), np.sin(angle) rotation_matrix = np.array([[c, -s], [s, c]]) vec = np.matmul(rotation_matrix, vec) return self.__class__(center.x + vec[0], center.y + vec[1]) regions-0.4/regions/core/tests/0000755000076600000240000000000013501657425016634 5ustar deilstaff00000000000000regions-0.4/regions/core/tests/__init__.py0000644000076600000240000000000013336761120020725 0ustar deilstaff00000000000000regions-0.4/regions/core/tests/test_bounding_box.py0000644000076600000240000000704613501414013022711 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import (absolute_import, division, print_function, unicode_literals) from numpy.testing import assert_allclose import pytest from ..bounding_box import BoundingBox try: import matplotlib HAS_MATPLOTLIB = True except: HAS_MATPLOTLIB = False def test_bounding_box_init(): bbox = BoundingBox(1, 10, 2, 20) assert bbox.ixmin == 1 assert bbox.ixmax == 10 assert bbox.iymin == 2 assert bbox.iymax == 20 def test_bounding_box_init_minmax(): with pytest.raises(ValueError): BoundingBox(100, 1, 1, 100) with pytest.raises(ValueError): BoundingBox(1, 100, 100, 1) def test_bounding_box_inputs(): with pytest.raises(TypeError): BoundingBox([1], [10], [2], [9]) with pytest.raises(TypeError): BoundingBox([1, 2], 10, 2, 9) with pytest.raises(TypeError): BoundingBox(1.0, 10.0, 2.0, 9.0) with pytest.raises(TypeError): BoundingBox(1.3, 10, 2, 9) with pytest.raises(TypeError): BoundingBox(1, 10.3, 2, 9) with pytest.raises(TypeError): BoundingBox(1, 10, 2.3, 9) with pytest.raises(TypeError): BoundingBox(1, 10, 2, 9.3) def test_bounding_box_from_float(): # This is the example from the method docstring bbox = BoundingBox.from_float(xmin=1.0, xmax=10.0, ymin=2.0, ymax=20.0) assert bbox == BoundingBox(ixmin=1, ixmax=11, iymin=2, iymax=21) bbox = BoundingBox.from_float(xmin=1.4, xmax=10.4, ymin=1.6, ymax=10.6) assert bbox == BoundingBox(ixmin=1, ixmax=11, iymin=2, iymax=12) def test_bounding_box_eq(): bbox = BoundingBox(1, 10, 2, 20) assert bbox == bbox assert bbox != BoundingBox(9, 10, 2, 20) assert bbox != BoundingBox(1, 99, 2, 20) assert bbox != BoundingBox(1, 10, 9, 20) assert bbox != BoundingBox(1, 10, 2, 99) def test_bounding_box_repr(): bbox = BoundingBox(1, 10, 2, 20) assert repr(bbox) == 'BoundingBox(ixmin=1, ixmax=10, iymin=2, iymax=20)' assert eval(repr(bbox)) == bbox def test_bounding_box_shape(): bbox = BoundingBox(1, 10, 2, 20) assert bbox.shape == (18, 9) def test_bounding_box_slices(): bbox = BoundingBox(1, 10, 2, 20) assert bbox.slices == (slice(2, 20), slice(1, 10)) def test_bounding_box_extent(): bbox = BoundingBox(1, 10, 2, 20) assert_allclose(bbox.extent, (0.5, 9.5, 1.5, 19.5)) @pytest.mark.skipif('not HAS_MATPLOTLIB') def test_bounding_box_as_artist(): bbox = BoundingBox(1, 10, 2, 20) patch = bbox.as_artist() assert_allclose(patch.get_xy(), (0.5, 1.5)) assert_allclose(patch.get_width(), 9) assert_allclose(patch.get_height(), 18) def test_bounding_box_union(): bbox1 = BoundingBox(1, 10, 2, 20) bbox2 = BoundingBox(5, 21, 7, 32) bbox_union_expected = BoundingBox(1, 21, 2, 32) bbox_union1 = bbox1 | bbox2 bbox_union2 = bbox1.union(bbox2) assert bbox_union1 == bbox_union_expected assert bbox_union1 == bbox_union2 with pytest.raises(TypeError): bbox1.union((5, 21, 7, 32)) def test_bounding_box_intersect(): bbox1 = BoundingBox(1, 10, 2, 20) bbox2 = BoundingBox(5, 21, 7, 32) bbox_intersect_expected = BoundingBox(5, 10, 7, 20) bbox_intersect1 = bbox1 & bbox2 bbox_intersect2 = bbox1.intersection(bbox2) assert bbox_intersect1 == bbox_intersect_expected assert bbox_intersect1 == bbox_intersect2 with pytest.raises(TypeError): bbox1.intersection((5, 21, 7, 32)) assert bbox1.intersection(BoundingBox(30, 40, 50, 60)) is None regions-0.4/regions/core/tests/test_compound.py0000644000076600000240000001324313501650710022062 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import operator import numpy as np from numpy.testing import assert_allclose import astropy.units as u from astropy.coordinates import SkyCoord from ...shapes import CircleSkyRegion, CirclePixelRegion from ...core import PixCoord, CompoundPixelRegion from ...tests.helpers import make_simple_wcs class TestCompoundPixel(object): # Two circles that overlap in one column c1 = CirclePixelRegion(PixCoord(5, 5), 4) c2 = CirclePixelRegion(PixCoord(11, 5), 4) def test_copy(self): reg = (self.c1 | self.c2).copy() assert isinstance(reg, CompoundPixelRegion) assert reg.operator == operator.or_ assert isinstance(reg.region1, CirclePixelRegion) assert reg.region1.center.xy == (5, 5) assert reg.region1.radius == 4 assert reg.region1.meta == {} assert reg.region1.visual == {} assert isinstance(reg.region2, CirclePixelRegion) assert reg.region2.center.xy == (11, 5) assert reg.region2.radius == 4 assert reg.region2.meta == {} assert reg.region2.visual == {} def test_rotate(self): reg = (self.c1 | self.c2).rotate(PixCoord(0, 0), 360 * u.deg) assert isinstance(reg, CompoundPixelRegion) assert reg.operator == operator.or_ assert isinstance(reg.region1, CirclePixelRegion) assert_allclose(reg.region1.center.xy, (5, 5)) assert reg.region1.radius == 4 assert reg.region1.meta == {} assert reg.region1.visual == {} assert isinstance(reg.region2, CirclePixelRegion) assert_allclose(reg.region2.center.xy, (11, 5)) assert reg.region2.radius == 4 assert reg.region2.meta == {} assert reg.region2.visual == {} def test_union(self): union = self.c1 | self.c2 assert isinstance(union, CompoundPixelRegion) mask = union.to_mask() assert_allclose(mask.data[:, 7], [0, 0, 1, 1, 1, 1, 1, 0, 0]) assert_allclose(mask.data[:, 6], [0, 1, 1, 1, 1, 1, 1, 1, 0]) def test_intersection(self): intersection = self.c1 & self.c2 mask = intersection.to_mask() assert_allclose(mask.data[:, 7], [0, 0, 1, 1, 1, 1, 1, 0, 0]) assert_allclose(mask.data[:, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0]) def test_symdiff(self): symdiff = self.c1 ^ self.c2 mask = symdiff.to_mask() assert_allclose(mask.data[:, 7], [0, 0, 0, 0, 0, 0, 0, 0, 0]) assert_allclose(mask.data[:, 6], [0, 1, 1, 1, 1, 1, 1, 1, 0]) def test_to_mask(self): # fixes #168 pixcoord3 = PixCoord(1, 1) c3 = CirclePixelRegion(pixcoord3, 4) union2 = self.c1 | c3 mask1 = union2.to_mask() pixcoord4 = PixCoord(9, 9) c4 = CirclePixelRegion(pixcoord4, 4) union3 = self.c1 | c4 mask2 = union3.to_mask() # mask1 and mask2 should be equal assert_allclose(mask1.data, mask2.data) ref_data = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0], [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0], [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] ) assert_allclose(mask1.data, ref_data) def test_compound_sky(): skycoord1 = SkyCoord(0 * u.deg, 0 * u.deg, frame='galactic') c1 = CircleSkyRegion(skycoord1, 1 * u.deg) skycoord2 = SkyCoord(1 * u.deg, 1 * u.deg, frame='galactic') c2 = CircleSkyRegion(skycoord2, 0.5 * u.deg) test_coord1 = SkyCoord(1.2 * u.deg, 1.2 * u.deg, frame='galactic') test_coord2 = SkyCoord(0.5 * u.deg, 0.5 * u.deg, frame='galactic') test_coord3 = SkyCoord(0.7 * u.deg, 0.7 * u.deg, frame='galactic') test_coord4 = SkyCoord(2 * u.deg, 5 * u.deg, frame='galactic') wcs = make_simple_wcs(skycoord1, 0.1 * u.deg, 20) assert c2.contains(test_coord1, wcs) and not c1.contains(test_coord1, wcs) assert not c2.contains(test_coord2, wcs) and c1.contains(test_coord2, wcs) assert c1.contains(test_coord3, wcs) and c2.contains(test_coord3, wcs) assert not c2.contains(test_coord4, wcs) and not c1.contains(test_coord4, wcs) coords = SkyCoord([test_coord1, test_coord2, test_coord3, test_coord4], frame='galactic') union = c1 | c2 assert (union.contains(coords, wcs) == [True, True, True, False]).all() intersection = c1 & c2 assert (intersection.contains(coords, wcs) == [False, False, True, False]).all() diff = c1 ^ c2 assert (diff.contains(coords, wcs) == [True, True, False, False]).all() c3 = CircleSkyRegion(test_coord4, 0.1 * u.deg) union = c1 | c2 | c3 assert (union.contains(coords, wcs) == [True, True, True, True]).all() intersection = c1 & c2 & c3 assert (intersection.contains(coords, wcs) == [False, False, False, False]).all() diff = c1 ^ c2 ^ c3 assert (diff.contains(coords, wcs) == [True, True, False, True]).all() assert 'Compound' in str(union) regions-0.4/regions/core/tests/test_mask.py0000644000076600000240000000603013501414013021157 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import (absolute_import, division, print_function, unicode_literals) import numpy as np from numpy.testing import assert_allclose import pytest from ..bounding_box import BoundingBox from ..mask import RegionMask from ..pixcoord import PixCoord from ...shapes import CirclePixelRegion try: import matplotlib # noqa HAS_MATPLOTLIB = True except ImportError: HAS_MATPLOTLIB = False POSITIONS = [(-20, -20), (-20, 20), (20, -20), (60, 60)] def test_mask_input_shapes(): with pytest.raises(ValueError): mask_data = np.ones((10, 10)) bbox = BoundingBox(5, 10, 5, 10) RegionMask(mask_data, bbox) def test_mask_array(): mask_data = np.ones((10, 10)) bbox = BoundingBox(5, 15, 5, 15) mask = RegionMask(mask_data, bbox) data = np.array(mask) assert_allclose(data, mask.data) def test_mask_cutout_shape(): mask_data = np.ones((10, 10)) bbox = BoundingBox(5, 15, 5, 15) mask = RegionMask(mask_data, bbox) with pytest.raises(ValueError): mask.cutout(np.arange(10)) with pytest.raises(ValueError): mask._overlap_slices((10,)) with pytest.raises(ValueError): mask.to_image((10,)) def test_mask_cutout_copy(): data = np.ones((50, 50)) aper = CirclePixelRegion(PixCoord(25, 25), radius=10.) mask = aper.to_mask() cutout = mask.cutout(data, copy=True) data[25, 25] = 100. assert cutout[10, 10] == 1. @pytest.mark.parametrize('position', POSITIONS) def test_mask_cutout_no_overlap(position): data = np.ones((50, 50)) aper = CirclePixelRegion(PixCoord(position[0], position[1]), radius=10.) mask = aper.to_mask() cutout = mask.cutout(data) assert cutout is None weighted_data = mask.multiply(data) assert weighted_data is None image = mask.to_image(data.shape) assert image is None @pytest.mark.parametrize('position', POSITIONS) def test_mask_cutout_partial_overlap(position): data = np.ones((50, 50)) aper = CirclePixelRegion(PixCoord(position[0], position[1]), radius=30.) mask = aper.to_mask() cutout = mask.cutout(data) assert cutout.shape == mask.shape weighted_data = mask.multiply(data) assert weighted_data.shape == mask.shape image = mask.to_image(data.shape) assert image.shape == data.shape def test_mask_nan_in_bbox(): """ Regression test that non-finite data values outside of the mask but within the bounding box are set to zero. """ data = np.ones((101, 101)) data[33, 33] = np.nan data[67, 67] = np.inf data[33, 67] = -np.inf data[22, 22] = np.nan data[22, 23] = np.inf radius = 20. reg1 = CirclePixelRegion(PixCoord(50, 50), radius) reg2 = CirclePixelRegion(PixCoord(5, 5), radius) wdata1 = reg1.to_mask(mode='exact').multiply(data) assert_allclose(np.sum(wdata1), np.pi * radius**2) wdata2 = reg2.to_mask(mode='exact').multiply(data) assert_allclose(np.sum(wdata2), 561.6040111923013) regions-0.4/regions/core/tests/test_pixcoord.py0000644000076600000240000001361713501414017022070 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from numpy.testing import assert_equal, assert_allclose import pytest from astropy import units as u from ..._utils.examples import make_example_dataset from ..pixcoord import PixCoord @pytest.fixture(scope='session') def wcs(): config = dict(crpix=(18, 9), cdelt=(-10, 10), shape=(18, 36)) dataset = make_example_dataset(config=config) return dataset.wcs def test_pixcoord_copy_scalar(): p = PixCoord(x=1, y=2) p2 = p.copy() p.x = 99 p.y = 99 assert p2.xy == (1, 2) def test_pixcoord_copy_array(): p = PixCoord(x=[1, 2], y=[3, 4]) p2 = p.copy() p.x[0] = 99 p.y[0] = 99 assert_equal(p2.x, [1, 2]) assert_equal(p2.y, [3, 4]) def test_pixcoord_basic_dimension(): with pytest.raises(ValueError): PixCoord(np.array([1, 2]), [3, 4, 5, 6]) def test_pixcoord_basics_scalar(): p = PixCoord(x=1, y=2) p1 = PixCoord(x=np.array(1), y=2) p2 = PixCoord(x=np.array(1), y=np.array(2)) assert p == p1 assert p1 == p2 assert p.x == 1 assert p.y == 2 assert p.isscalar assert p1.isscalar assert p2.isscalar assert str(p) == 'PixCoord(x=1, y=2)' assert repr(p) == 'PixCoord(x=1, y=2)' with pytest.raises(TypeError): len(p) with pytest.raises(IndexError): p[0] def test_pixcoord_basics_array_1d(): p = PixCoord(x=[1, 2, 3], y=[11, 22, 33]) p1 = PixCoord(x=1, y=[1, 2, 3]) assert_equal(p.x, [1, 2, 3]) assert_equal(p.y, [11, 22, 33]) assert_equal(p1.x, [1, 1, 1]) assert_equal(p1.y, [1, 2, 3]) assert not p.isscalar assert not p1.isscalar assert str(p) == 'PixCoord(x=[1 2 3], y=[11 22 33])' assert str(p1) == 'PixCoord(x=[1 1 1], y=[1 2 3])' assert repr(p) == 'PixCoord(x=[1 2 3], y=[11 22 33])' assert repr(p1) == 'PixCoord(x=[1 1 1], y=[1 2 3])' assert len(p) == 3 assert len(p1) == 3 # Test `__iter__` via assertions on the last element p2 = [_ for _ in p][-1] assert p2.x == 3 assert p2.y == 33 # Test `__getitem__ p3 = p[-1] assert p3.isscalar assert p3.x == 3 assert p3.y == 33 p4 = p[1:] assert len(p4) == 2 assert_equal(p4.x, [2, 3]) assert_equal(p4.y, [22, 33]) def test_pixcoord_basics_array_2d(): p = PixCoord( [[1, 2, 3], [4, 5, 6]], [[11, 12, 13], [14, 15, 16]], ) assert_equal(p.x, [[1, 2, 3], [4, 5, 6]]) assert_equal(p.y, [[11, 12, 13], [14, 15, 16]]) assert p.isscalar is False # TODO: this repr with the newline isn't nice ... improve it somehow? expected = ('PixCoord(x=[[1 2 3]\n [4 5 6]], ' 'y=[[11 12 13]\n [14 15 16]])') assert str(p) == expected assert repr(p) == expected assert len(p) == 2 # TODO: does `__iter__` and `__getitem__` make sense for 2d array case? # (see tests above) def test_pixcoord_to_sky_scalar(wcs): p = PixCoord(x=18, y=9) s = p.to_sky(wcs=wcs) assert s.name == 'galactic' assert_allclose(s.data.lon.deg, 349.88093995435634) assert_allclose(s.data.lat.deg, 10.003028030623508) p2 = PixCoord.from_sky(skycoord=s, wcs=wcs) assert isinstance(p2.x, float) assert p2.isscalar assert p == p2 def test_pixcoord_to_sky_array_1d(wcs): p = PixCoord(x=[17, 18], y=[8, 9]) s = p.to_sky(wcs=wcs) assert s.name == 'galactic' assert_allclose(s.data.lon.deg, [0, 349.88094]) assert_allclose(s.data.lat.deg, [0, 10.003028]) p2 = PixCoord.from_sky(skycoord=s, wcs=wcs) assert isinstance(p2.x, np.ndarray) assert p2.x.shape == (2,) assert not p2.isscalar assert p == p2 def test_pixcoord_to_sky_array_2d(wcs): p1 = PixCoord(x=[[17, 17, 17], [18, 18, 18]], y=[[8, 8, 8], [9, 9, 9]]) p = PixCoord(x=[[17, 18]], y=[[8, 9]]) s = p.to_sky(wcs=wcs) assert s.name == 'galactic' s1 = p1.to_sky(wcs=wcs) assert s.name == 'galactic' assert_allclose(s1.data.lon.deg, [[0, 0, 0], [349.88094, 349.88094, 349.88094]]) assert_allclose(s1.data.lat.deg, [[0, 0, 0], [10.003028, 10.003028, 10.003028]]) assert_allclose(s.data.lon.deg, [[0, 349.88094]]) assert_allclose(s.data.lat.deg, [[0, 10.003028]]) p2 = PixCoord.from_sky(skycoord=s, wcs=wcs) assert isinstance(p2.x, np.ndarray) assert p2.x.shape == (1, 2) assert not p2.isscalar assert p == p2 def test_pixcoord_separation_scalar(): p1 = PixCoord(x=1, y=2) p2 = PixCoord(x=4, y=6) sep = p1.separation(p2) assert_allclose(sep, 5) def test_pixcoord_separation_array_1d(): p1 = PixCoord(x=[1, 1], y=[2, 2]) p2 = PixCoord(x=[4, 4], y=[6, 6]) sep = p1.separation(p2) assert_allclose(sep, [5, 5]) def test_pixcoord_separation_array_2d(): p1 = PixCoord(x=[[1, 1]], y=[[2, 2]]) p2 = PixCoord(x=[[4, 4]], y=[[6, 6]]) sep = p1.separation(p2) assert isinstance(sep, np.ndarray) assert sep.shape == (1, 2) assert_allclose(sep, [[5, 5]]) def test_equality(): a = np.array([1, 2]) b = PixCoord(a[0], a[1]) c = PixCoord(a[0] + 0.0000001, a[1]) assert not b == a assert b == b assert b == c a = PixCoord( [[1, 2, 3], [4, 5, 6]], [[11, 12, 13], [14, 15, 16]], ) b = PixCoord( [[1, 2, 3], [4, 5, 6]], [[11.0000002, 12, 13], [14, 15, 16]], ) assert a == b assert a == a def test_pixcoord_xy(): a = np.array([1, 2]) pc = PixCoord(a[0], a[1]) assert pc.xy[0] == pc.x assert pc.xy[1] == pc.y def test_pixcoord_rotate_scalar(): point = PixCoord(3, 4) center = PixCoord(2, 3) point = point.rotate(center, 90 * u.deg) assert_allclose(point.xy, (1, 4)) def test_pixcoord_rotate_array(): point = PixCoord([3, 3], [4, 4]) center = PixCoord(2, 3) point = point.rotate(center, 90 * u.deg) assert_allclose(point.xy, ([1, 1], [4, 4])) regions-0.4/regions/cython_version.py0000644000076600000240000000007213501657424020163 0ustar deilstaff00000000000000# Generated file; do not modify cython_version = '0.29.6' regions-0.4/regions/io/0000755000076600000240000000000013501657425015151 5ustar deilstaff00000000000000regions-0.4/regions/io/__init__.py0000644000076600000240000000037013336761120017254 0ustar deilstaff00000000000000from .core import * from .ds9.read import * from .ds9.write import * from .ds9.core import * from .crtf.read import * from .crtf.write import * from .crtf.core import * from .fits.core import * from .fits.read import * from .fits.write import * regions-0.4/regions/io/core.py0000644000076600000240000007656413477731541016501 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function from warnings import warn import string import numbers import numpy as np from astropy import units as u from astropy import coordinates from astropy.coordinates import Angle, SkyCoord from astropy import log from astropy.table import Table from .. import shapes from ..core import PixCoord, SkyRegion from ..core.attributes import RegionMeta, RegionVisual from .ds9.core import DS9RegionParserWarning, valid_symbols_ds9 from .crtf.core import CRTFRegionParserWarning __all__ = ['ShapeList', 'Shape', 'to_shape_list', 'to_crtf_meta', 'to_ds9_meta'] class RegionConversionError(ValueError): """ A generic error class for Shape to Region conversion. """ regions_attributes = dict(circle=['center', 'radius'], ellipse=['center', 'width', 'height', 'angle'], rectangle=['center', 'width', 'height', 'angle'], polygon=['vertices'], circleannulus=['center', 'inner_radius', 'outer_radius'], ellipseannulus=['center', 'inner_width', 'inner_height', 'outer_width', 'outer_height', 'angle'], line=['start', 'end'], point=['center'], text=['center'] ) regions_attributes['rectangleannulus'] = regions_attributes['ellipseannulus'] # This helps to map the region names in the respective format to the ones # available in this package reg_mapping = {'DS9': {x: x for x in regions_attributes}, 'CRTF': {x: x for x in regions_attributes}, 'FITS_REGION': {x: x for x in regions_attributes}} reg_mapping['DS9']['box'] = 'rectangle' reg_mapping['CRTF']['rotbox'] = 'rectangle' reg_mapping['CRTF']['box'] = 'rectangle' reg_mapping['CRTF']['centerbox'] = 'rectangle' reg_mapping['CRTF']['poly'] = 'polygon' reg_mapping['CRTF']['symbol'] = 'point' reg_mapping['CRTF']['text'] = 'text' reg_mapping['CRTF']['annulus'] = 'circleannulus' reg_mapping['DS9']['text'] = 'text' reg_mapping['DS9']['annulus'] = 'circleannulus' reg_mapping['FITS_REGION']['annulus'] = 'circleannulus' reg_mapping['FITS_REGION']['box'] = 'rectangle' reg_mapping['FITS_REGION']['rotbox'] = 'rectangle' reg_mapping['FITS_REGION']['elliptannulus'] = 'ellipseannulus' # valid astropy coordinate frames in their respective formats. valid_coordsys = {'DS9': ['image', 'physical', 'fk4', 'fk5', 'icrs', 'galactic', 'geocentrictrueecliptic', 'wcs'], 'CRTF': ['image', 'fk5', 'fk4', 'galactic', 'geocentrictrueecliptic', 'supergalactic', 'icrs'] } valid_coordsys['DS9'] += ['wcs{}'.format(x) for x in string.ascii_lowercase] # Maps astropy's coordinate frame names with their respective name in the file format. coordsys_mapping = {'DS9': {x: x for x in valid_coordsys['DS9']}, 'CRTF': {x: x for x in valid_coordsys['CRTF']} } coordsys_mapping['CRTF']['geocentrictrueecliptic'] = 'ecliptic' coordsys_mapping['CRTF']['fk5'] = 'j2000' coordsys_mapping['CRTF']['fk4'] = 'b1950' coordsys_mapping['CRTF']['supergalactic'] = 'supergal' coordsys_mapping['DS9']['geocentrictrueecliptic'] = 'ecliptic' class ShapeList(list): """List of Shape""" def to_regions(self): regions = list() for shape in self: # Skip elliptical annulus for now if shape.region_type == 'ellipse' and len(shape.coord) > 5: msg = 'Skipping elliptical annulus {}'.format(shape) warn(msg, DS9RegionParserWarning) continue if shape.region_type in ['box'] and shape.format_type == 'CRTF': msg = 'Skipping {} {}'.format(shape.region_type, shape) warn(msg, CRTFRegionParserWarning) continue log.debug(shape) region = shape.to_region() log.debug(region) regions.append(region) return regions def to_crtf(self, coordsys='fk5', fmt='.6f', radunit='deg'): """ Converts a list of ``regions.Shape`` objects to crtf region strings. Parameters ---------- coordsys : str This overrides the coordinate system frame for all regions. fmt : str A python string format defining the output precision. Default is .6f, which is accurate to 0.0036 arcseconds. radunit : str This denotes the unit of the radius. Returns ------- region_string : str crtf region string Examples -------- TODO """ crtf_strings = { 'circle': '{0}circle[[{1:FMT}deg, {2:FMT}deg], {3:FMT}RAD]', 'circleannulus': '{0}annulus[[{1:FMT}deg, {2:FMT}deg], [{3:FMT}RAD, {4:FMT}RAD]]', 'ellipse': '{0}ellipse[[{1:FMT}deg, {2:FMT}deg], [{3:FMT}RAD, {4:FMT}RAD], {5:FMT}deg]', 'rectangle': '{0}rotbox[[{1:FMT}deg, {2:FMT}deg], [{3:FMT}RAD, {4:FMT}RAD], {5:FMT}deg]', 'polygon': '{0}poly[{1}]', 'point': '{0}point[[{1:FMT}deg, {2:FMT}deg]]', 'symbol': '{0}symbol[[{1:FMT}deg, {2:FMT}deg], {symbol}]', 'text': '{0}text[[{1:FMT}deg, {2:FMT}deg], \'{text}\']', 'line': '{0}line[[{1:FMT}deg, {2:FMT}deg], [{3:FMT}deg, {4:FMT}deg]]' } output = '#CRTF\n' if radunit == 'arcsec': # what's this for? if coordsys in coordsys_mapping['CRTF'].values(): radunitstr = '"' else: raise ValueError( 'Radius unit arcsec not valid for coordsys {}'.format( coordsys)) else: radunitstr = radunit for key, val in crtf_strings.items(): crtf_strings[key] = val.replace("FMT", fmt).replace("RAD", radunitstr) # CASA does not support global coordinate specification, even though the # documentation for the specification explicitly states that it does. # output += 'global coord={}\n'.format(coordsys) for shape in self: shape.check_crtf() shape.meta = to_crtf_meta(shape.meta) # if unspecified, include is True. # Despite the specification, CASA does *not* support a preceding # "+". If you want a region included, leave the opening character # blank. include = "-" if shape.include in (False, '-') else "" include += "ann " if shape.meta.get('type', 'reg') == 'ann' else "" if shape.meta.get('label', "") != "": shape.meta['label'] = "'{}'".format(shape.meta['label']) meta_str = ", ".join("{0}={1}".format(key, val) for key, val in shape.meta.items() if key not in ('include', 'comment', 'symbol', 'coord', 'text', 'range', 'corr', 'type')) # the first item should be the coordinates, since CASA cannot # recognize a region without an inline coordinate specification # It can be, but does not need to be, comma-separated at the start meta_str = "coord={0}, ".format(coordsys.upper()) + meta_str if 'comment' in shape.meta: meta_str += ", " + shape.meta['comment'] if 'range' in shape.meta: shape.meta['range'] = [str(str(x).replace(" ", "")) for x in shape.meta['range']] meta_str += ", range={}".format(shape.meta['range']).replace("'", "") if 'corr' in shape.meta: meta_str += ", corr={}".format(shape.meta['corr']).replace("'", "") coord = [] if coordsys not in ['image', 'physical']: for val in shape.coord: if isinstance(val, Angle): coord.append(float(val.value)) else: if radunit == '' or None: coord.append(float(val.value)) else: coord.append(float(val.to(radunit).value)) else: for val in shape.coord: if isinstance(val, u.Quantity): coord.append(float(val.value)) else: coord.append(float(val)) if shape.region_type in ['ellipse', 'rectangle'] and len(shape.coord) % 2 == 1: coord[-1] = float(shape.coord[-1].to('deg').value) if shape.region_type == 'polygon': val = '[{0:' + fmt + '}deg, {1:' + fmt + '}deg]' temp = [val.format(x, y) for x, y in zip(coord[::2], coord[1::2])] coord = ", ".join(temp) line = crtf_strings['polygon'].format(include, coord) elif shape.region_type == 'point': if 'symbol' in shape.meta: line = crtf_strings['symbol'].format(include, *coord, symbol=shape.meta['symbol']) else: line = crtf_strings['point'].format(include, *coord) elif shape.region_type == 'ellipse': coord[2:] = [x / 2 for x in coord[2:]] if len(coord) % 2 == 1: coord[-1] *= 2 line = crtf_strings['ellipse'].format(include, *coord) elif shape.region_type == 'text': line = crtf_strings['text'].format(include, *coord, text=shape.meta['text']) else: line = crtf_strings[shape.region_type].format(include, *coord) if meta_str.strip(): output += "{0}, {1}\n".format(line, meta_str) else: output += "{0}\n".format(line) return output def to_ds9(self, coordsys='fk5', fmt='.6f', radunit='deg'): """ Converts a list of ``regions.Shape`` objects to ds9 region strings. Parameters ---------- coordsys : str This overrides the coordinate system frame for all regions. fmt : str A python string format defining the output precision. Default is .6f, which is accurate to 0.0036 arcseconds. radunit : str This denotes the unit of the radius. Returns ------- region_string : str ds9 region string Examples -------- TODO """ valid_symbols_reverse = {y: x for x, y in valid_symbols_ds9.items()} ds9_strings = { 'circle': '{0}circle({1:FMT},{2:FMT},{3:FMT}RAD)', 'circleannulus': '{0}annulus({1:FMT},{2:FMT},{3:FMT}RAD,{4:FMT}RAD)', 'ellipse': '{0}ellipse({1:FMT},{2:FMT},{3:FMT}RAD,{4:FMT}RAD,{5:FMT})', 'rectangle': '{0}box({1:FMT},{2:FMT},{3:FMT}RAD,{4:FMT}RAD,{5:FMT})', 'polygon': '{0}polygon({1})', 'point': '{0}point({1:FMT},{2:FMT})', 'line': '{0}line({1:FMT},{2:FMT},{3:FMT},{4:FMT})', 'text': '{0}text({1:FMT},{2:FMT})' } output = '# Region file format: DS9 astropy/regions\n' if radunit == 'arcsec': # what's this for? if coordsys in coordsys_mapping['DS9'].values(): radunitstr = '"' else: raise ValueError('Radius unit arcsec not valid for coordsys {}'.format(coordsys)) else: radunitstr = '' for key, val in ds9_strings.items(): ds9_strings[key] = val.replace("FMT", fmt).replace("RAD", radunitstr) output += '{}\n'.format(coordsys) for shape in self: shape.check_ds9() shape.meta = to_ds9_meta(shape.meta) # if unspecified, include is True. include = "-" if shape.include in (False, '-') else "" if 'point' in shape.meta: shape.meta['point'] = valid_symbols_reverse[shape.meta['point']] if 'symsize' in shape.meta: shape.meta['point'] += " {}".format(shape.meta.pop('symsize')) meta_str = " ".join("{0}={1}".format(key, val) for key, val in shape.meta.items() if key not in ('include', 'tag', 'comment', 'font', 'text')) if 'tag' in shape.meta: meta_str += " " + " ".join(["tag={0}".format(tag) for tag in shape.meta['tag']]) if 'font' in shape.meta: meta_str += " " + 'font="{0}"'.format(shape.meta['font']) if shape.meta.get('text', '') != '': meta_str += " " + 'text={' + shape.meta['text'] + '}' if 'comment' in shape.meta: meta_str += " " + shape.meta['comment'] coord = [] if coordsys not in ['image', 'physical']: for val in shape.coord: if isinstance(val, Angle): coord.append(float(val.value)) else: if radunit == '' or None: coord.append(float(val.value)) else: coord.append(float(val.to(radunit).value)) if shape.region_type in ['ellipse', 'rectangle'] and len(shape.coord) % 2 == 1: coord[-1] = float(shape.coord[-1].to('deg').value) else: for val in shape.coord: if isinstance(val, u.Quantity): coord.append(float(val.value)) else: coord.append(float(val)) if shape.region_type in ['polygon', 'line']: coord = [x+1 for x in coord] else: coord[0] += 1 coord[1] += 1 if shape.region_type == 'polygon': val = "{0:" + fmt + "}" temp = [val.format(x) for x in coord] coord = ",".join(temp) line = ds9_strings['polygon'].format(include, coord) elif shape.region_type == 'ellipse': coord[2:] = [x / 2 for x in coord[2:]] if len(coord) % 2 == 1: coord[-1] *= 2 line = ds9_strings['ellipse'].format(include, *coord) else: line = ds9_strings[shape.region_type].format(include, *coord) if meta_str.strip(): output += "{0} # {1}\n".format(line, meta_str) else: output += "{0}\n".format(line) return output def to_fits(self): """ Converts a `~regions.ShapeList` to a `~astropy.table.Table` object. """ max_length_coord = 1 coord_x = [] coord_y = [] shapes = [] radius = [] rotangle_deg = [] components = [] reg_reverse_mapping = {value: key for key, value in reg_mapping['FITS_REGION'].items()} reg_reverse_mapping['rectangle'] = 'ROTBOX' reg_reverse_mapping['circleannulus'] = 'ANNULUS' reg_reverse_mapping['ellipseannulus'] = 'ELLIPTANNULUS' for num, shape in enumerate(self): shapes.append(reg_reverse_mapping[shape.region_type]) if shape.region_type == 'polygon': max_length_coord = max(len(shape.coord)/2, max_length_coord) coord = [x.value for x in shape.coord] coord_x.append(coord[::2]) coord_y.append(coord[1::2]) radius.append(0) rotangle_deg.append(0) else: coord_x.append(shape.coord[0].value) coord_y.append(shape.coord[1].value) if shape.region_type in ['circle', 'circleannulus', 'point']: radius.append([float(val) for val in shape.coord[2:]]) rotangle_deg.append(0) else: radius.append([float(x) for x in shape.coord[2:-1]]) rotangle_deg.append(shape.coord[-1].to('deg').value) tag = shape.meta.get('tag', '') if tag.isdigit(): components.append(int(tag)) else: components.append(num + 1) # padding every value with zeros at the end to make sure that all values # in the column have same length. for i in range(len(self)): if np.isscalar(coord_x[i]): coord_x[i] = np.array([coord_x[i]]) if np.isscalar(coord_y[i]): coord_y[i] = np.array([coord_y[i]]) if np.isscalar(radius[i]): radius[i] = np.array([radius[i]]) coord_x[i] = np.pad(coord_x[i], (0, int(max_length_coord - len(coord_x[i]))), 'constant', constant_values=(0, 0)) coord_y[i] = np.pad(coord_y[i], (0, int(max_length_coord - len(coord_y[i]))), 'constant', constant_values=(0, 0)) radius[i] = np.pad(radius[i], (0, 4 - len(radius[i])), 'constant', constant_values=(0, 0)) table = Table([coord_x, coord_y, shapes, radius, rotangle_deg, components], names=('X', 'Y', 'SHAPE', 'R', 'ROTANG', 'COMPONENT')) table['X'].unit = 'pix' table['Y'].unit = 'pix' table['R'].unit = 'pix' table['ROTANG'].unit = 'deg' return table class Shape(object): """ Helper class to represent a DS9/CRTF Region. This serves as intermediate step in the parsing process. Parameters ---------- coordsys : str Astropy Coordinate system frame used in the region. region_type : str Type of the region (as defined in this package). coord : list of `~astropy.coordinates.Angle` or `~astropy.units.Quantity` Coordinates meta : dict Meta attributes composite : bool Composite region include : bool Include/exclude region """ shape_to_sky_region = dict(circle=shapes.CircleSkyRegion, ellipse=shapes.EllipseSkyRegion, rectangle=shapes.RectangleSkyRegion, polygon=shapes.PolygonSkyRegion, circleannulus=shapes.CircleAnnulusSkyRegion, ellipseannulus=shapes.EllipseAnnulusSkyRegion, rectangleannulus=shapes.RectangleAnnulusSkyRegion, line=shapes.LineSkyRegion, point=shapes.PointSkyRegion, text=shapes.TextSkyRegion ) shape_to_pixel_region = dict(circle=shapes.CirclePixelRegion, ellipse=shapes.EllipsePixelRegion, rectangle=shapes.RectanglePixelRegion, polygon=shapes.PolygonPixelRegion, circleannulus=shapes.CircleAnnulusPixelRegion, ellipseannulus=shapes.EllipseAnnulusPixelRegion, rectangleannulus=shapes.RectangleAnnulusPixelRegion, line=shapes.LinePixelRegion, point=shapes.PointPixelRegion, text=shapes.TextPixelRegion ) error = RegionConversionError def __init__(self, coordsys, region_type, coord, meta, composite, include): self._coordsys = coordsys self._region_type = region_type self.coord = coord self.meta = meta self.composite = composite self.include = include @property def coordsys(self): return self._coordsys @coordsys.setter def coordsys(self, value): self._coordsys = value.lower() self._validate() @property def region_type(self): return self._region_type @region_type.setter def region_type(self, value): self._region_type = value.lower() self._validate() def __str__(self): ss = self.__class__.__name__ ss += '\nType : {}'.format(self.meta.get('type', 'reg')) ss += '\nCoord sys : {}'.format(self.coordsys) ss += '\nRegion type : {}'.format(self.region_type) if self.region_type == 'symbol': ss += '\nSymbol : {}'.format(self.meta['symbol']) if self.region_type == 'text': ss += '\nText : {}'.format(self.meta['text']) ss += '\nMeta: {}'.format(self.meta) ss += '\nComposite: {}'.format(self.composite) ss += '\nInclude: {}'.format(self.include) ss += '\n' return ss def convert_coords(self): """ Process list of coordinates This mainly searches for tuple of coordinates in the coordinate list and creates a SkyCoord or PixCoord object from them if appropriate for a given region type. This involves again some coordinate transformation, so this step could be moved to the parsing process """ if self.coordsys in ['image', 'physical']: coords = self._convert_pix_coords() else: coords = self._convert_sky_coords() if self.region_type == 'line': coords = [coords[0][0], coords[0][1]] if self.region_type == 'text': coords.append(self.meta['text']) return coords def _convert_sky_coords(self): """ Convert to sky coordinates """ parsed_angles = [(x, y) for x, y in zip(self.coord[:-1:2], self.coord[1::2]) if (isinstance(x, coordinates.Angle) and isinstance(y, coordinates.Angle)) ] frame = coordinates.frame_transform_graph.lookup_name(self.coordsys) lon, lat = zip(*parsed_angles) if hasattr(lon, '__len__') and hasattr(lat, '__len__') and len(lon) == 1 and len(lat) == 1: # force entries to be scalar if they are length-1 lon, lat = u.Quantity(lon[0]), u.Quantity(lat[0]) else: # otherwise, they are vector quantities lon, lat = u.Quantity(lon), u.Quantity(lat) sphcoords = coordinates.UnitSphericalRepresentation(lon, lat) coords = [SkyCoord(frame(sphcoords))] if self.region_type != 'polygon': coords += self.coord[len(coords * 2):] return coords def _convert_pix_coords(self): """ Convert to pixel coordinates, `regions.PixCoord` """ if self.region_type in ['polygon', 'line']: # have to special-case polygon in the phys coord case # b/c can't typecheck when iterating as in sky coord case coords = [PixCoord(self.coord[0::2], self.coord[1::2])] else: temp = [_.value for _ in self.coord] coord = PixCoord(temp[0], temp[1]) coords = [coord] + temp[2:] # The angle remains as a quantity object. # Modulus check makes sure that it works for ellipse/rectangle annulus if self.region_type in ['ellipse', 'rectangle'] and len(coords) % 2 == 0: coords[-1] = self.coord[-1] return coords def to_region(self): """ Converts to region, ``regions.Region`` object """ coords = self.convert_coords() log.debug(coords) viz_keywords = ['color', 'dash', 'dashlist', 'width', 'font', 'symsize', 'symbol', 'symsize', 'fontsize', 'fontstyle', 'usetex', 'labelpos', 'labeloff', 'linewidth', 'linestyle', 'point', 'textangle', 'fontweight'] if isinstance(coords[0], SkyCoord): reg = self.shape_to_sky_region[self.region_type](*coords) elif isinstance(coords[0], PixCoord): reg = self.shape_to_pixel_region[self.region_type](*coords) else: self._raise_error("No central coordinate") reg.visual = RegionVisual() reg.meta = RegionMeta() # both 'text' and 'label' should be set to the same value, where we # default to the 'text' value since that is the one used by ds9 regions label = self.meta.get('text', self.meta.get('label', "")) if label != '': reg.meta['label'] = label for key in self.meta: if key in viz_keywords: reg.visual[key] = self.meta[key] else: reg.meta[key] = self.meta[key] reg.meta['include'] = self.include return reg def _raise_error(self, msg): raise self.error(msg) def check_crtf(self): """ Checks for CRTF compatibility. """ if self.region_type not in regions_attributes: raise ValueError("'{0}' is not a valid region type in this package" "supported by CRTF".format(self.region_type)) if self.coordsys not in valid_coordsys['CRTF']: raise ValueError("'{0}' is not a valid coordinate reference frame in " "astropy supported by CRTF".format(self.coordsys)) def check_ds9(self): """ Checks for DS9 compatibility. """ if self.region_type not in regions_attributes: raise ValueError("'{0}' is not a valid region type in this package" "supported by DS9".format(self.region_type)) if self.coordsys not in valid_coordsys['DS9']: raise ValueError("'{0}' is not a valid coordinate reference frame " "in astropy supported by DS9".format(self.coordsys)) def _validate(self): """ Checks whether all the attributes of this object is valid. """ if self.region_type not in regions_attributes: raise ValueError("'{0}' is not a valid region type in this package" .format(self.region_type)) if self.coordsys not in valid_coordsys['DS9'] + valid_coordsys['CRTF']: raise ValueError("'{0}' is not a valid coordinate reference frame " "in astropy".format(self.coordsys)) def to_shape_list(region_list, coordinate_system='fk5'): """ Converts a list of regions into a `regions.ShapeList` object. Parameters ---------- region_list: python list Lists of `regions.Region` objects format_type: str ('DS9' or 'CRTF') The format type of the Shape object. Default is 'DS9'. coordinate_system: str The astropy coordinate system frame in which all the coordinates present in the `region_list` will be converted. Default is 'fk5'. Returns ------- shape_list: `regions.ShapeList` object list of `regions.Shape` objects. """ shape_list = ShapeList() for region in region_list: coord = [] if isinstance(region, SkyRegion): reg_type = region.__class__.__name__[:-9].lower() else: reg_type = region.__class__.__name__[:-11].lower() for val in regions_attributes[reg_type]: coord.append(getattr(region, val)) if reg_type == 'polygon': coord = [x for x in region.vertices] if coordinate_system: coordsys = coordinate_system else: if isinstance(region, SkyRegion): coordsys = coord[0].name else: coordsys = 'image' frame = coordinates.frame_transform_graph.lookup_name(coordsys) new_coord = [] for val in coord: if isinstance(val, Angle) or isinstance(val, u.Quantity) or isinstance(val, numbers.Number): new_coord.append(val) elif isinstance(val, PixCoord): new_coord.append(u.Quantity(val.x, u.dimensionless_unscaled)) new_coord.append(u.Quantity(val.y, u.dimensionless_unscaled)) else: new_coord.append(Angle(val.transform_to(frame).spherical.lon)) new_coord.append(Angle(val.transform_to(frame).spherical.lat)) meta = dict(region.meta) meta.update(region.visual) if reg_type == 'text': meta['text'] = meta.get('text', meta.pop('label', '')) include = region.meta.pop('include', True) shape_list.append(Shape(coordsys, reg_type, new_coord, meta, False, include)) return shape_list def to_ds9_meta(shape_meta): """ Makes the meta data DS9 compatible by filtering and mapping the valid keys Parameters ---------- shape_meta: dict meta attribute of a `regions.Shape` object Returns ------- meta : dict DS9 compatible meta dictionary """ # meta keys allowed in DS9. valid_keys = ['symbol', 'include', 'tag', 'line', 'comment', 'name', 'select', 'highlite', 'fixed', 'label', 'text', 'edit', 'move', 'rotate', 'delete', 'source', 'background'] # visual keys allowed in DS9 valid_keys += ['color', 'dash', 'linewidth', 'font', 'dashlist', 'fill', 'textangle', 'symsize'] # mapped to actual names in DS9 key_mappings = {'symbol': 'point', 'linewidth': 'width', 'label': 'text'} meta = _to_io_meta(shape_meta, valid_keys, key_mappings) if 'font' in meta: meta['font'] += " {0} {1} {2}".format(shape_meta.get('fontsize', 12), shape_meta.get('fontstyle', 'normal'), shape_meta.get('fontweight', 'roman')) return meta def to_crtf_meta(shape_meta): """ Makes the meta data CRTF compatible by filtering and mapping the valid keys Parameters ---------- shape_meta: dict meta attribute of a `regions.Region` object Returns ------- meta : dict CRTF compatible meta dictionary """ # please refer : https://casaguides.nrao.edu/index.php/CASA_Region_Format # meta keys allowed in CRTF valid_keys = ['label', 'include', 'frame', 'range', 'veltype', 'restfreq', 'coord', 'type', 'text', 'corr'] # visual keys allowed in CRTF valid_keys += ['color', 'width', 'font', 'symthick', 'symsize', 'fontsize', 'fontstyle', 'usetex', 'labelpos', 'labeloff', 'linewidth', 'linestyle', 'symbol'] key_mappings = {} return _to_io_meta(shape_meta, valid_keys, key_mappings) def _to_io_meta(shape_meta, valid_keys, key_mappings): """ This is used to make meta data compatible with a specific io by filtering and mapping to it's valid keys Parameters ---------- shape_meta: dict meta attribute of a `regions.Region` object valid_keys : python list Contains all the valid keys of a particular file format. key_mappings : python dict Maps to the actual name of the key in the format. Returns ------- meta : dict io compatible meta dictionary according to valid_keys and key_mappings """ meta = dict() for key in shape_meta: if key in valid_keys: meta[key_mappings.get(key, key)] = shape_meta[key] return meta regions-0.4/regions/io/crtf/0000755000076600000240000000000013501657425016107 5ustar deilstaff00000000000000regions-0.4/regions/io/crtf/__init__.py0000644000076600000240000000000013336761120020200 0ustar deilstaff00000000000000regions-0.4/regions/io/crtf/core.py0000644000076600000240000000241513477731541017417 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function from astropy.utils.exceptions import AstropyUserWarning __all__ = [ 'CRTFRegionParserWarning', 'CRTFRegionParserError', ] class CRTFRegionParserWarning(AstropyUserWarning): """ A generic warning class for CRTF region parsing """ class CRTFRegionParserError(ValueError): """ A generic error class for CRTF region parsing """ # Valid symbols for symbol region in CRTF. valid_symbols = {'.': 'point', ',': 'pixel', 'o': 'circle', 'v': 'triangle_down', '^': 'triangle_up', '<': 'triangle_left', '>': 'triangle_right', '1': 'tri_down', '2': 'tri_up', '3': 'tri_left', '4': 'tri_right', 's': 'square', 'p': 'pentagon', '*': 'star', 'h': 'hexagon1', 'H': 'hexagon2', '+': 'plus', 'x': 'x', 'D': 'diamond', 'd': 'thin_diamond', '|': 'vline', '_': 'hline' } regions-0.4/regions/io/crtf/read.py0000644000076600000240000004370513501414013017365 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function import re import six import copy import itertools from warnings import warn from astropy import units as u from astropy import coordinates from .core import CRTFRegionParserError, CRTFRegionParserWarning, valid_symbols from ..core import Shape, ShapeList, reg_mapping __all__ = ['read_crtf', 'CRTFParser', 'CRTFRegionParser'] # All CASA files start with '#CRTF' . It may also include the version number like '#CRTFv0' . regex_begin = re.compile(r'^#CRTFv?[\d]?$') # Comment Format : regex_comment = re.compile(r'^#.*$') # Identifies the global attributes Format. regex_global = re.compile(r'^global\s+(?P.*)?') # Coordinate Format : "[x, y]" regex_coordinate = re.compile(r'\[([\w.+-:]*?)\s*[,]\s*([\w.+-:]*?)\]') # Single length Format. For Ex : helps us to extract the radius of a circle. regex_length = re.compile(r'(?:\[[^=]*\])+[,]\s*([^\[]*)\]') # Extracts each 'parameter=value' pair. regex_meta = re.compile(r'(?:(\w+)\s*=[\s\'\"]*([^,\[\]]+?)[\'\",]+)|(?:(\w+)\s*=\s*\[(.*?)\])') # Region format which segregates include('+'|'-') parameter, kind of definition ('ann' for annotations | '' for regions) # and region type. regex_region = re.compile(r'(?P[+-])?(?Pann(?=\s))?\s*(?P[a-z]*?)\[[^=]*]') # Line format which checks the validity of the line and segregates the meta attributes from the region format. regex_line = re.compile(r'(?P[+-]?(?:ann(?=\s))?\s*[a-z]+?\[[^=]+\])(?:\s*[,]\s*(?P.*))?') def read_crtf(filename, errors='strict'): """ Reads a CRTF region file and returns a list of region objects. Parameters ---------- filename : `str` The file path errors : ``warn``, ``ignore``, ``strict``, optional The error handling scheme to use for handling parsing errors. The default is 'strict', which will raise a `~regions.CRTFRegionParserError`. ``warn`` will raise a `~regions.CRTFRegionParserWarning`, and ``ignore`` will do nothing (i.e., be silent). Returns ------- regions : `list` Python `list` of `~regions.Region` objects. Examples -------- >>> from regions import read_crtf >>> from astropy.utils.data import get_pkg_data_filename >>> file = get_pkg_data_filename('data/CRTFgeneral.crtf', package='regions.io.crtf.tests') >>> regs = read_crtf(file, errors='warn') >>> print(regs[0].visual) {'color': 'blue'} """ with open(filename) as fh: if regex_begin.search(fh.readline()): region_string = fh.read() parser = CRTFParser(region_string, errors) return parser.shapes.to_regions() else: raise CRTFRegionParserError('Every CRTF Region must start with "#CRTF" ') class CRTFParser(object): """ Parses a CRTF string. This class transforms a CRTF string to a `~regions.io.core.ShapeList`. The result is stored as ``shapes`` attribute. Each line is tested for either containing a region with meta attributes or global parameters. If global parameters are found then, it is stored in the ``global_meta`` attribute. If a region is found the `~regions.CRTFRegionParser` is invoked to transform the line into a `~regions.io.core.Shape` object. Parameters ---------- region_string : `str` CRTF region string errors : ``warn``, ``ignore``, ``strict``, optional The error handling scheme to use for handling parsing errors. The default is 'strict', which will raise a `~regions.CRTFRegionParserError`. ``warn`` will raise a `~regions.CRTFRegionParserWarning`, and ``ignore`` will do nothing (i.e., be silent). Examples -------- >>> from regions import CRTFParser >>> reg_str = "ann circle[[18h12m24s, -23d11m00s], 2.3arcsec], coord=B1950, frame=BARY, corr=[I, Q], color=blue" >>> regs = CRTFParser(reg_str, errors='warn').shapes.to_regions() >>> print(regs[0].visual) {'color': 'blue'} """ # It contains a tuple of valid definition (region, annotation) type. valid_definition = ('box', 'centerbox', 'rotbox', 'poly', 'circle', 'annulus', 'ellipse', 'line', 'vector', 'text', 'symbol') # It contains a tuple of valid name of the parameters(attributes). valid_global_keys = ('coord', 'frame', 'corr', 'veltype', 'restfreq', 'linewidth', 'linestyle', 'symsize', 'symthick', 'color', 'font', 'fontsize', 'fontstyle', 'usetex', 'labelpos','labelcolor', 'labeloff', 'range') def __init__(self, region_string, errors='strict'): if errors not in ('strict', 'ignore', 'warn'): msg = "``errors`` must be one of strict, ignore, or warn; is {}" raise ValueError(msg.format(errors)) self.region_string = region_string self.errors = errors # Global states self.global_meta = {} # Results self.shapes = ShapeList() self.run() def __str__(self): ss = self.__class__.__name__ ss += '\nErrors: {}'.format(self.errors) ss += '\nGlobal meta: {}'.format(self.global_meta) ss += '\nShapes: {}'.format(self.shapes) ss += '\n' return ss def parse_line(self, line): """ Parses a single line. """ # Skip blanks if line == '': return # Skip comments if regex_comment.search(line): return # Special case / header: parse global parameters into metadata global_parameters = regex_global.search(line) if global_parameters: self.parse_global_meta(global_parameters.group('parameters')) return # Tries to check the validity of the line. crtf_line = regex_line.search(line) if crtf_line: # Tries to parse the line. # Finds info about the region. region = regex_region.search(crtf_line.group('region')) type_ = region.group('type') or 'reg' include = region.group('include') or '+' region_type = region.group('regiontype').lower() if region_type in self.valid_definition: helper = CRTFRegionParser(self.global_meta, include, type_, region_type, *crtf_line.group('region', 'parameters')) self.shapes.append(helper.shape) else: self._raise_error("Not a valid CRTF Region type: '{0}'.".format(region_type)) else: self._raise_error("Not a valid CRTF line: '{0}'.".format(line)) return def _raise_error(self, msg): if self.errors == 'warn': warn(msg, CRTFRegionParserWarning) elif self.errors == 'strict': raise CRTFRegionParserError(msg) def run(self): """ Run all the steps. Splits the regions into line and calls ``parse_line`` for each line. """ for line in self.region_string.split('\n'): self.parse_line(line) def parse_global_meta(self, global_meta_str): """ Parses the line starting with global to extract all the valid meta key/value pair. """ if global_meta_str: global_meta_str = regex_meta.findall(global_meta_str + ',') if global_meta_str: for par in global_meta_str: if par[0] is not '': val1 = par[0].lower() val2 = par[1] else: val1 = par[2].lower() val2 = par[3] val1 = val1.strip() val2 = val2.strip() if val1 in self.valid_global_keys : if val1 in ('range', 'corr', 'labeloff'): val2 = val2.split(",") val2 = [x.strip() for x in val2 if x] self.global_meta[val1] = val2 else: self._raise_error("'{0}' is not a valid global meta key".format(val1)) class CRTFRegionParser(object): """ Parse a CRTF region string This will turn a line containing a CRTF region into a `~regions.Shape` object. Parameters ---------- global_meta : `dict` Global meta data of the CRTF file which is used as default meta values for regions include : `str` {'+', '-'} Flag at the beginning of the line type_ : `str` {'reg', 'ann'} Kind of the region definition region_type : `str` Region type reg_str : `str` Region string to parse meta_str : `str` Meta string to parse errors : ``warn``, ``ignore``, ``strict``, optional The error handling scheme to use for handling parsing errors. The default is 'strict', which will raise a `~regions.CRTFRegionParserError`. ``warn`` will raise a `~regions.CRTFRegionParserWarning`, and ``ignore`` will do nothing (i.e., be silent). """ # List of valid coordinate system # TODO : There are still many reference systems to support coordinate_systems = ['j2000', 'icrs', 'galactic', 'supergal', 'image', 'ecliptic'] # Maps CASA coordinate frame to appropriate astropy coordinate frames. coordsys_mapping = dict(zip(coordinates.frame_transform_graph.get_names(), coordinates.frame_transform_graph.get_names())) coordsys_mapping['j2000'] = 'fk5' coordsys_mapping['b1950'] = 'fk4' coordsys_mapping['supergal'] = 'supergalactic' coordsys_mapping['ecliptic'] = 'geocentrictrueecliptic' # CRTF Format specifications. This define how a certain region is read. # 'c' denotes a coordinates, 'l' denotes a length, 'pl' denotes a pair of lengths, # 's' denotes a string(generally a text or symbol) language_spec = {'circle': ['c', 'l'], 'box': ['c', 'c'], 'centerbox': ['c', 'pl'], 'rotbox': ['c', 'pl', 'l'], 'poly': itertools.cycle('c'), 'annulus': ['c', 'pl'], 'ellipse': ['c', 'pl', 'l'], 'line': ['c', 'c'], 'vector': ['c', 'c'], 'symbol': ['c', 's'], 'text': ['c', 's']} def __init__(self, global_meta, include, type_, region_type, reg_str, meta_str, errors='strict'): self.global_meta = global_meta self.reg_str = reg_str self.meta_str = meta_str self.errors = errors self.coord = None self.coordsys = None self.coord_str = None self.type_ = type_ self.region_type = region_type self.meta = copy.deepcopy(global_meta) self.shape = None self.include = include or '+' self.parse() def _raise_error(self, msg): if self.errors == 'warn': warn(msg, CRTFRegionParserWarning) elif self.errors == 'strict': raise CRTFRegionParserError(msg) def parse(self): """ Starting point to parse the CRTF region string. """ self.convert_meta() self.coordsys = self.meta.get('coord', 'image').lower() self.set_coordsys() self.convert_coordinates() self.make_shape() def set_coordsys(self): """ Mapping to astropy's coordinate system name # TODO: needs expert attention (Most reference systems are not mapped) """ if self.coordsys.lower() in self.coordsys_mapping: self.coordsys = self.coordsys_mapping[self.coordsys.lower()] def convert_coordinates(self): """ Convert coordinate string to `~astropy.coordinates.Angle` or `~astropy.units.quantity.Quantity` objects """ coord_list_str = regex_coordinate.findall(self.reg_str) + regex_length.findall(self.reg_str) coord_list = [] if self.region_type == 'poly': if len(coord_list_str) < 4: self._raise_error('Not in proper format: {} polygon should have > 4 coordinates'.format(self.reg_str)) if coord_list_str[0] != coord_list_str[-1]: self._raise_error("Not in proper format: '{0}', " "In polygon, the last and first coordinates should be same".format(self.reg_str)) else: if len(coord_list_str) != len(self.language_spec[self.region_type]): self._raise_error("Not in proper format: '{0}', " "Does not contain expected number of parameters for the region '{1}'" .format(self.reg_str, self.region_type)) for attr_spec, val_str in zip(self.language_spec[self.region_type], coord_list_str): if attr_spec == 'c': if len(val_str) == 2 and val_str[1] != '': coord_list.append(CoordinateParser.parse_coordinate(val_str[0])) coord_list.append(CoordinateParser.parse_coordinate(val_str[1])) else: self._raise_error("Not in proper format: {0} should be a coordinate".format(val_str)) if attr_spec == 'pl': if len(val_str) == 2 and val_str[1] != '': coord_list.append(CoordinateParser.parse_angular_length_quantity(val_str[0])) coord_list.append(CoordinateParser.parse_angular_length_quantity(val_str[1])) else: self._raise_error("Not in proper format: {0} should be a pair of length".format(val_str)) if attr_spec == 'l': if isinstance(val_str, six.string_types): coord_list.append(CoordinateParser.parse_angular_length_quantity(val_str)) else: self._raise_error("Not in proper format: {0} should be a single length".format(val_str)) if attr_spec == 's': if self.region_type == 'symbol': if val_str in valid_symbols: self.meta['symbol'] = val_str else: self._raise_error("Not in proper format: '{0}' should be a symbol".format(val_str)) elif self.region_type == 'text': self.meta['text'] = val_str[1:-1] self.coord = coord_list def convert_meta(self): """ Parses the meta_str to python dictionary and stores in ``meta`` attribute. """ if self.meta_str: self.meta_str = regex_meta.findall(self.meta_str + ',') if self.meta_str: for par in self.meta_str: if par[0] is not '': val1 = par[0] val2 = par[1] else: val1 = par[2] val2 = par[3] val1 = val1.strip() val2 = val2.strip() if val1 in CRTFParser.valid_global_keys or val1 == 'label': if val1 in ('range', 'corr', 'labeloff'): val2 = val2.split(',') val2 = [x.strip() for x in val2] self.meta[val1] = val2 else: self._raise_error("'{0}' is not a valid meta key".format(val1)) self.meta['include'] = self.include != '-' self.include = self.meta['include'] if 'range' in self.meta: self.meta['range'] = [u.Quantity(x) for x in self.meta['range']] self.meta['type'] = self.type_ def make_shape(self): """ Make shape object """ if self.region_type == 'ellipse': self.coord[2:] = [x * 2 for x in self.coord[2:]] if len(self.coord) % 2 == 1: # This checks if the angle is present. self.coord[-1] /= 2 if self.region_type == 'box': x = (self.coord[0] + self.coord[2]) / 2 y = (self.coord[1] + self.coord[3]) / 2 w = u.Quantity(self.coord[0] - self.coord[2]) h = u.Quantity(self.coord[1] - self.coord[3]) self.coord = [x, y, abs(w), abs(h)] self.meta.pop('coord', None) self.shape = Shape(coordsys=self.coordsys, region_type=reg_mapping['CRTF'][self.region_type], coord=self.coord, meta=self.meta, composite=False, include=self.include ) class CoordinateParser(object): """ Helper class to structure coordinate parser """ @staticmethod def parse_coordinate(string_rep): """ Parse a single coordinate """ # Any CRTF coordinate representation (sexagesimal or degrees) if 'pix' in string_rep: return u.Quantity(string_rep[:-3], u.dimensionless_unscaled) if 'h' in string_rep or 'rad' in string_rep: return coordinates.Angle(string_rep) if len(string_rep.split('.')) >= 3: string_rep = string_rep.replace('.', ':', 2) return coordinates.Angle(string_rep, u.deg) @staticmethod def parse_angular_length_quantity(string_rep): """ Given a string that is a number and a unit, return a Quantity of that string.Raise an Error If there is no unit. e.g.: 50" -> 50*u.arcsec 50 -> CRTFRegionParserError : Units must be specified for 50 """ unit_mapping = { 'deg': u.deg, 'rad': u.rad, 'arcmin': u.arcmin, 'arcsec': u.arcsec, 'pix': u.dimensionless_unscaled, '"': u.arcsec, "'": u.arcmin, } regex_str = re.compile(r'([0-9+,-.]*)(.*)') str = regex_str.search(string_rep) unit = str.group(2) if unit: if unit in unit_mapping: return u.Quantity(str.group(1), unit=unit_mapping[unit]) return u.Quantity(str.group(1)) else: raise CRTFRegionParserError('Units must be specified for {0} '.format(string_rep)) regions-0.4/regions/io/crtf/setup_package.py0000644000076600000240000000025613477731541021303 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst def get_package_data(): parser_test = ['data/*.crtf'] return {'regions.io.crtf.tests': parser_test} regions-0.4/regions/io/crtf/tests/0000755000076600000240000000000013501657425017251 5ustar deilstaff00000000000000regions-0.4/regions/io/crtf/tests/__init__.py0000644000076600000240000000000013336761120021342 0ustar deilstaff00000000000000regions-0.4/regions/io/crtf/tests/data/0000755000076600000240000000000013501657425020162 5ustar deilstaff00000000000000regions-0.4/regions/io/crtf/tests/data/CRTFgeneral.crtf0000644000076600000240000000204213337457452023141 0ustar deilstaff00000000000000#CRTF0 global coord=B1950, frame=BARY, corr=[I, Q], color=blue # A simple circle region: ann circle[[18h12m24s, -23d11m00s], 2.3arcsec] # A box region, this one only for annotation: (Not Implemented ) # ann box[[140.0342deg, -12.34243deg], [140.0360deg, -12.34320deg]] # A rotated box region, for a particular range of velocities: rotbox[[12h01m34.1s, 12d23m32s], [3arcmin, 1arcmin], 12deg], range=[-1240km/s, 1240km/s] # An annular region, overriding some of the global defaults: annulus[[17h51m03.2s, -45d17m50s], [0.10deg, 4.12deg]], corr=[I,Q,U,V], color=red, label='My label here' # Cuts an ellipse out of the previous regions, but only for Q and a particular frequency range: -ellipse[[12deg, +45deg], [0.25deg, 1.34deg], 45rad], range=[1.420GHz, 1.421GHz], corr=[Q], color=green, label='Removed this' # A diamond marker, in J2000 coordinates: symbol[[32.1423deg, 12.1412deg], D], linewidth=2, coord=J2000, symsize=2 # Text region text[[32.1423deg, 12.1412deg], 'my text'], linewidth=2, coord=J2000 # Box region box[[1deg, 2deg], [3deg, 4deg]] regions-0.4/regions/io/crtf/tests/data/CRTFgeneraloutput.crtf0000644000076600000240000000153213426512374024417 0ustar deilstaff00000000000000#CRTF ann circle[[273.100deg, -23.183deg], 0.001deg], coord=FK4, frame=BARY, color=blue, corr=[I, Q] rotbox[[180.392deg, 12.392deg], [0.050deg, 0.017deg], 12.000deg], coord=FK4, frame=BARY, color=blue, range=[-1240.0km/s, 1240.0km/s], corr=[I, Q] annulus[[267.763deg, -45.297deg], [0.100deg, 4.120deg]], coord=FK4, label='My label here', frame=BARY, color=red, corr=[I, Q, U, V] -ellipse[[12.000deg, 45.000deg], [0.250deg, 1.340deg], 2578.310deg], coord=FK4, label='Removed this', frame=BARY, color=green, range=[1.42GHz, 1.421GHz], corr=[Q] symbol[[31.470deg, 11.905deg], D], coord=FK4, frame=BARY, color=blue, linewidth=2, symsize=2, corr=[I, Q] text[[31.470deg, 11.905deg], 'my text'], coord=FK4, frame=BARY, color=blue, linewidth=2, corr=[I, Q] rotbox[[2.000deg, 3.000deg], [2.000deg, 2.000deg], 0.000deg], coord=FK4, frame=BARY, color=blue, corr=[I, Q] regions-0.4/regions/io/crtf/tests/test_crtf_language.py0000644000076600000240000001057413477731541023476 0ustar deilstaff00000000000000 import distutils.version as vers import pytest import astropy.version as astrov from astropy.utils.data import get_pkg_data_filename from ..read import CRTFParser, read_crtf from ..write import crtf_objects_to_string from ..core import CRTFRegionParserError _ASTROPY_MINVERSION = vers.LooseVersion('1.1') _ASTROPY_VERSION = vers.LooseVersion(astrov.version) implemented_region_types = ('ellipse', 'circle', 'rectangle', 'poly', 'point', 'text', 'symbol') def test_global_parser(): """ Checks that the global_parser does what's expected. """ global_test_str = str("global coord=B1950_VLA, frame=BARY, corr=[I, Q], color=blue") global_parser = CRTFParser(global_test_str) assert dict(global_parser.global_meta) == {'coord': 'B1950_VLA', 'frame': 'BARY', 'corr': ['I', 'Q'], 'color': 'blue'} def test_valid_crtf_line(): """ Checks whether a the line is valid CRTF format. """ line_str = 'coord=B1950_VLA, frame=BARY, corr=[I, Q], color=blue' with pytest.raises(CRTFRegionParserError) as err: CRTFParser(line_str) assert 'Not a valid CRTF line:' in str(err) def test_valid_region_type(): """ Checks whether the region type is valid in CRTF format """ reg_str = 'hyperbola[[18h12m24s, -23d11m00s], 2.3arcsec]' with pytest.raises(CRTFRegionParserError) as err: CRTFParser(reg_str) assert "Not a valid CRTF Region type: 'hyperbola'" in str(err) def test_valid_global_meta_key(): """ Checks whether the global key is valid or not. """ global_test_str = str("global label=B1950_VLA, frame=BARY, corr=[I, Q], color=blue") with pytest.raises(CRTFRegionParserError) as err: CRTFParser(global_test_str) assert "'label' is not a valid global meta key" in str(err) def test_valid_meta_key(): """ Checks whether the key is valid or not. """ meta_test_str = str("annulus[[17h51m03.2s, -45d17m50s], [0.10deg, 4.12deg]], hello='My label here'") with pytest.raises(CRTFRegionParserError) as err: CRTFParser(meta_test_str) assert "'hello' is not a valid meta key" in str(err) def test_valid_region_syntax(): """ Checks whether the region has valid parameters """ reg_str1 = "circle[[18h12m24s, -23d11m00s], [2.3arcsec,4.5arcsec]" with pytest.raises(CRTFRegionParserError) as err: CRTFParser(reg_str1) assert "Not in proper format: ('2.3arcsec', '4.5arcsec') should be a single length" in str(err) reg_str2 = "symbol[[32.1423deg, 12.1412deg], 12deg], linewidth=2, coord=J2000, symsize=2" with pytest.raises(CRTFRegionParserError) as err: CRTFParser(reg_str2) assert "Not in proper format: '12deg' should be a symbol" in str(err) reg_str3 = "circle[[18h12m24s, -23d11m00s]" with pytest.raises(CRTFRegionParserError) as err: CRTFParser(reg_str3) assert "Does not contain expected number of parameters for the region 'circle'" in str(err) reg_str4 = "poly[[1, 2], [3,4], [5, 6]]" with pytest.raises(CRTFRegionParserError) as err: CRTFParser(reg_str4) assert "polygon should have > 4 coordinates" in str(err) reg_str5 = "poly[[1, 2], [3,4], [5, 6],[1,6]]" with pytest.raises(CRTFRegionParserError) as err: CRTFParser(reg_str5) assert "In polygon, the last and first coordinates should be same" in str(err) reg_str6 = "rotbox[[12h01m34.1s, 12d23m33s], [3arcmin,], 12deg]" with pytest.raises(CRTFRegionParserError) as err: CRTFParser(reg_str6) assert "('3arcmin', '') should be a pair of length" in str(err) @pytest.mark.parametrize('filename', ['data/CRTFgeneral.crtf', 'data/CRTFgeneraloutput.crtf']) def test_file_crtf(filename): filename = get_pkg_data_filename(filename) regs = read_crtf(filename, 'warn') actual_output = crtf_objects_to_string(regs, 'fk4', '.3f').strip() with open(get_pkg_data_filename('data/CRTFgeneraloutput.crtf')) as f: ref_output = f.read().strip() # since metadata is not required to preserve order, we have to do a more # complex comparison desired_lines = [set(line.split(",")) for line in ref_output.split("\n")] actual_lines = [set(line.split(",")) for line in actual_output.split("\n")] for split_line in actual_lines: assert split_line in desired_lines for split_line in desired_lines: assert split_line in actual_lines regions-0.4/regions/io/crtf/write.py0000644000076600000240000000451613501414013017601 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals from ..core import to_shape_list __all__ = [ 'write_crtf', 'crtf_objects_to_string', ] def crtf_objects_to_string(regions, coordsys='fk5', fmt='.6f', radunit='deg'): """ Converts a `list` of `~regions.Region` to CRTF region string. Parameters ---------- regions : `list` List of `~regions.Region` objects coordsys : `str`, optional Astropy Coordinate system that overrides the coordinate system frame for all regions. Default is 'fk5'. fmt : `str`, optional A python string format defining the output precision. Default is .6f, which is accurate to 0.0036 arcseconds. radunit : `str`, optional This denotes the unit of the radius. Default is deg (degrees) Returns ------- region_string : `str` CRTF region string Examples -------- >>> from astropy import units as u >>> from astropy.coordinates import SkyCoord >>> from regions import CircleSkyRegion, crtf_objects_to_string >>> reg_sky = CircleSkyRegion(SkyCoord(1 * u.deg, 2 * u.deg), 5 * u.deg) >>> print(crtf_objects_to_string([reg_sky])) #CRTF circle[[1.000007deg, 2.000002deg], 5.000000deg], coord=FK5, """ shapelist = to_shape_list(regions, coordsys) return shapelist.to_crtf(coordsys, fmt, radunit) def write_crtf(regions, filename, coordsys='fk5', fmt='.6f', radunit='deg'): """ Converts a `list` of `~regions.Region` to CRTF string and write to file. See :ref:`gs-crtf` Parameters ---------- regions : `list` List of `~regions.Region` objects filename : `str` Filename in which the string is to be written. Default is 'new.crtf' coordsys : `str`, optional Astropy Coordinate system that overrides the coordinate frames of all regions. Default is 'fk5'. fmt : `str`, optional A python string format defining the output precision. Default is .6f, which is accurate to 0.0036 arcseconds. radunit : `str`, optional This denotes the unit of the radius. Default is deg (degrees) """ output = crtf_objects_to_string(regions, coordsys, fmt, radunit) with open(filename, 'w') as fh: fh.write(output) regions-0.4/regions/io/ds9/0000755000076600000240000000000013501657425015650 5ustar deilstaff00000000000000regions-0.4/regions/io/ds9/__init__.py0000644000076600000240000000000013336761120017741 0ustar deilstaff00000000000000regions-0.4/regions/io/ds9/core.py0000644000076600000240000000150713477731541017161 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function from astropy.utils.exceptions import AstropyUserWarning __all__ = [ 'DS9RegionParserWarning', 'DS9RegionParserError', ] class DS9RegionParserWarning(AstropyUserWarning): """ A generic warning class for DS9 region parsing inherited from astropy's warnings """ class DS9RegionParserError(ValueError): """ A generic error class for DS9 region parsing """ # mapping to matplotlib marker symbols, also compatible with CRTF. valid_symbols_ds9 = dict(circle="o", box="s", diamond="D", x="x", cross="+", arrow="^", boxcircle="*") regions-0.4/regions/io/ds9/read.py0000644000076600000240000004610213501414013017120 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function import string import itertools import re import copy from collections import OrderedDict from warnings import warn from astropy import units as u from astropy import coordinates from astropy import log from ..core import reg_mapping from ..core import Shape, ShapeList from .core import DS9RegionParserError, DS9RegionParserWarning, valid_symbols_ds9 __all__ = [ 'read_ds9', 'DS9Parser', 'DS9RegionParser', 'CoordinateParser' ] # Regular expression to extract region type or coodinate system regex_global = re.compile("^#? *(-?)([a-zA-Z0-9]+)") # Regular expression to extract meta attributes regex_meta = re.compile(r"([a-zA-Z]+)(=)({.*?}|\'.*?\'|\".*?\"|[0-9\s]+\s?|[^=\s]+\s?[0-9]*)\s?") # Regular expression to strip parenthesis regex_paren = re.compile("[()]") # Regular expression to split coordinate strings regex_splitter = re.compile("[, ]") def read_ds9(filename, errors='strict'): """ Read a DS9 region file in as a `list` of `~regions.Region` objects. Parameters ---------- filename : `str` The file path errors : ``warn``, ``ignore``, ``strict``, optional The error handling scheme to use for handling parsing errors. The default is 'strict', which will raise a `~regions.DS9RegionParserError`. ``warn`` will raise a `~regions.DS9RegionParserWarning`, and ``ignore`` will do nothing (i.e., be silent). Returns ------- regions : `list` Python list of `~regions.Region` objects. Examples -------- >>> from regions import read_ds9 >>> from astropy.utils.data import get_pkg_data_filename >>> file = get_pkg_data_filename('data/physical_reference.reg', package='regions.io.ds9.tests') >>> regs = read_ds9(file, errors='warn') >>> print(regs[0]) Region: CirclePixelRegion center: PixCoord(x=330.0, y=1090.0) radius: 40.0 """ with open(filename) as fh: region_string = fh.read() parser = DS9Parser(region_string, errors=errors) return parser.shapes.to_regions() class CoordinateParser(object): """ Helper class to structure coordinate parser """ @staticmethod def parse_coordinate(string_rep, unit): """ Parse a single coordinate """ # explicit radian ('r') value if string_rep[-1] == 'r': return coordinates.Angle(string_rep[:-1], unit=u.rad) # explicit image ('i') and physical ('p') pixels elif string_rep[-1] in ['i', 'p']: return u.Quantity(string_rep[:-1]) - 1 # Any ds9 coordinate representation (sexagesimal or degrees) elif 'd' in string_rep or 'h' in string_rep: return coordinates.Angle(string_rep) elif unit is 'hour_or_deg': if ':' in string_rep: spl = tuple([float(x) for x in string_rep.split(":")]) return coordinates.Angle(spl, u.hourangle) else: ang = float(string_rep) return coordinates.Angle(ang, u.deg) elif unit.is_equivalent(u.deg): # return coordinates.Angle(string_rep, unit=unit) if ':' in string_rep: ang = tuple([float(x) for x in string_rep.split(":")]) else: ang = float(string_rep) return coordinates.Angle(ang, u.deg) elif unit.is_equivalent(u.dimensionless_unscaled): return u.Quantity(float(string_rep), unit) - 1 else: return u.Quantity(float(string_rep), unit) @staticmethod def parse_angular_length_quantity(string_rep, unit=u.deg): """ Given a string that is either a number or a number and a unit, return a Quantity of that string. e.g.: 23.9 -> 23.9*u.deg 50" -> 50*u.arcsec """ unit_mapping = { '"': u.arcsec, "'": u.arcmin, 'd': u.deg, 'r': u.rad, 'i': u.dimensionless_unscaled, 'p': u.dimensionless_unscaled } has_unit = string_rep[-1] not in string.digits if has_unit: unit = unit_mapping[string_rep[-1]] return u.Quantity(float(string_rep[:-1]), unit=unit) else: return u.Quantity(float(string_rep), unit=unit) class DS9Parser(object): """ Parse a DS9 string This class transforms a DS9 string to a `~regions.io.core.ShapeList`. The result is stored as ``shapes`` attribute. Each line is tested for either containing a region type or a coordinate system. If a coordinate system is found the global coordsys state of the parser is modified. If a region type is found the `~regions.DS9RegionParser` is invokes to transform the line into a `~regions.Shape` object. Parameters ---------- region_string : `str` DS9 region string errors : ``warn``, ``ignore``, ``strict``, optional The error handling scheme to use for handling parsing errors. The default is 'strict', which will raise a `~regions.DS9RegionParserError`. ``warn`` will raise a `~regions.DS9RegionParserWarning`, and ``ignore`` will do nothing (i.e., be silent). Examples -------- >>> from regions import DS9Parser >>> reg_str = 'image\\n circle(331.00,1091.00,40.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Circle} tag={foo} tag={foo bar} This is a Comment color=pink width=3 font="times 10 normal roman"' >>> regs = DS9Parser(reg_str, errors='warn').shapes.to_regions() >>> print(regs[0]) Region: CirclePixelRegion center: PixCoord(x=330.0, y=1090.0) radius: 40.0 """ # List of valid coordinate system coordinate_systems = ['fk5', 'fk4', 'icrs', 'galactic', 'wcs', 'physical', 'image', 'ecliptic', 'J2000'] coordinate_systems += ['wcs{0}'.format(letter) for letter in string.ascii_lowercase] # Map to convert coordinate system names coordsys_mapping = dict(zip(coordinates.frame_transform_graph.get_names(), coordinates.frame_transform_graph.get_names())) coordsys_mapping['ecliptic'] = 'geocentrictrueecliptic' coordsys_mapping['J2000'] = 'fk5' def __init__(self, region_string, errors='strict'): if errors not in ('strict', 'ignore', 'warn'): msg = "``errors`` must be one of strict, ignore, or warn; is {}" raise ValueError(msg.format(errors)) self.region_string = region_string self.errors = errors # Global states self.coordsys = None self.global_meta = {} # Results self.shapes = ShapeList() self.run() def __str__(self): ss = self.__class__.__name__ ss += '\nErrors: {}'.format(self.errors) ss += '\nCoordsys: {}'.format(self.coordsys) ss += '\nGlobal meta: {}'.format(self.global_meta) ss += '\nShapes: {}'.format(self.shapes) ss += '\n' return ss def set_coordsys(self, coordsys): """ Transform coordinate system # TODO: needs expert attention """ if coordsys in self.coordsys_mapping: self.coordsys = self.coordsys_mapping[coordsys] else: self.coordsys = coordsys def run(self): """ Run all steps """ for line_ in self.region_string.split('\n'): for line in line_.split(";"): self.parse_line(line) log.debug('Global state: {}'.format(self)) def parse_line(self, line): """ Parse one line """ log.debug('Parsing {}'.format(line)) # Skip blanks if line == '': return # Skip comments if line[0] == '#': return # Special case / header: parse global parameters into metadata if line.lstrip()[:6] == 'global': self.global_meta = self.parse_meta(line) # global_meta can specify "include=1"; never seen other options # used but presumably =0 means false self.global_meta['include'] = (False if self.global_meta.get('include') in ('0', 'False', False) else True) return # Try to parse the line region_type_search = regex_global.search(line) if region_type_search: include = region_type_search.groups()[0] region_type = region_type_search.groups()[1] else: self._raise_error("No region type found for line '{0}'.".format(line)) return if region_type in self.coordinate_systems: # Found coord system definition self.set_coordsys(region_type) return if region_type not in DS9RegionParser.language_spec: self._raise_error("Region type '{0}' was identified, but it is not one of " "the known region types.".format(region_type)) return else: # Found region specification, region_end = region_type_search.span()[1] self.parse_region(include, region_type, region_end, line) def _raise_error(self, msg): if self.errors == 'warn': warn(msg, DS9RegionParserWarning) elif self.errors == 'strict': raise DS9RegionParserError(msg) @staticmethod def parse_meta(meta_str): """ Parse the metadata for a single ds9 region string. Parameters ---------- meta_str : `str` Meta string, the metadata is everything after the close-paren of the region coordinate specification. All metadata is specified as key=value pairs separated by whitespace, but sometimes the values can also be whitespace separated. Returns ------- meta : `~collections.OrderedDict` Dictionary containing the meta data """ keys_vals = [(x, y) for x, _, y in regex_meta.findall(meta_str.strip())] extra_text = regex_meta.split(meta_str.strip())[-1] result = OrderedDict() for key, val in keys_vals: # regex can include trailing whitespace or inverted commas # remove it val = val.strip().strip("'").strip('"') if key == 'text': val = val.lstrip("{").rstrip("}") if key in result: if key == 'tag': result[key].append(val) else: raise ValueError("Duplicate key {0} found".format(key)) else: if key == 'tag': result[key] = [val] else: result[key] = val if extra_text: result['comment'] = extra_text return result def parse_region(self, include, region_type, region_end, line): """ Extract a Shape from a region string """ if self.coordsys is None: raise DS9RegionParserError("No coordinate system specified and a" " region has been found.") else: helper = DS9RegionParser(coordsys=self.coordsys, include=include, region_type=region_type, region_end=region_end, global_meta=self.global_meta, line=line) helper.parse() self.shapes.append(helper.shape) # Global definitions to improve readability radius = CoordinateParser.parse_angular_length_quantity width = CoordinateParser.parse_angular_length_quantity height = CoordinateParser.parse_angular_length_quantity angle = CoordinateParser.parse_angular_length_quantity coordinate = CoordinateParser.parse_coordinate class DS9RegionParser(object): """ Parse a DS9 region string This will turn a line containing a DS9 region into a Shape Parameters ---------- coordsys : `str` Coordinate system include : `str` {'', '-'} Flag at the beginning of the line region_type : `str` Region type region_end : `int` Coordinate of the end of the regions name, this is passed in order to handle whitespaces correctly global_meta : `dict` Global meta data line : `str` Line to parse """ # Coordinate unit transformations coordinate_units = {'fk5': ('hour_or_deg', u.deg), 'fk4': ('hour_or_deg', u.deg), 'icrs': ('hour_or_deg', u.deg), 'geocentrictrueecliptic': (u.deg, u.deg), 'galactic': (u.deg, u.deg), 'physical': (u.dimensionless_unscaled, u.dimensionless_unscaled), 'image': (u.dimensionless_unscaled, u.dimensionless_unscaled), 'wcs': (u.dimensionless_unscaled, u.dimensionless_unscaled), } for letter in string.ascii_lowercase: coordinate_units['wcs{0}'.format(letter)] = (u.dimensionless_unscaled, u.dimensionless_unscaled) # DS9 language specification. This defines how a certain region is read. language_spec = {'point': (coordinate, coordinate), 'text': (coordinate, coordinate), 'circle': (coordinate, coordinate, radius), # This is a special case to deal with n elliptical annuli 'ellipse': itertools.chain((coordinate, coordinate), itertools.cycle((radius,))), 'box': (coordinate, coordinate, width, height, angle), 'polygon': itertools.cycle((coordinate,)), 'line': (coordinate, coordinate, coordinate, coordinate), 'annulus': itertools.chain((coordinate, coordinate), itertools.cycle((radius,))), } def __init__(self, coordsys, include, region_type, region_end, global_meta, line): self.coordsys = coordsys self.include = include self.region_type = region_type self.region_end = region_end self.global_meta = global_meta self.line = line self.meta_str = None self.coord_str = None self.composite = None self.coord = None self.meta = None self.shape = None def __str__(self): ss = self.__class__.__name__ ss += '\nLine : {}'.format(self.line) ss += '\nRegion end : {}'.format(self.region_end) ss += '\nMeta string : {}'.format(self.meta_str) ss += '\nCoord string: {}'.format(self.coord_str) ss += '\nShape: {}'.format(self.shape) ss += '\n' return ss def parse(self): """ Convert line to shape object """ log.debug(self) self.parse_composite() self.split_line() self.convert_coordinates() self.convert_meta() self.make_shape() log.debug(self) def parse_composite(self): """ Determine whether the region is composite """ self.composite = "||" in self.line def split_line(self): """ Split line into coordinates and meta string """ # coordinate of the # symbol or end of the line (-1) if not found hash_or_end = self.line.find("#") temp = self.line[self.region_end:hash_or_end].strip(" |") self.coord_str = regex_paren.sub("", temp) # don't want any meta_str if there is no metadata found if hash_or_end >= 0: self.meta_str = self.line[hash_or_end:] else: self.meta_str = "" def convert_coordinates(self): """ Convert coordinate string to objects """ coord_list = [] # strip out "null" elements, i.e. ''. It might be possible to eliminate # these some other way, i.e. with regex directly, but I don't know how. # We need to copy in order not to burn up the iterators elements = [x for x in regex_splitter.split(self.coord_str) if x] element_parsers = self.language_spec[self.region_type] for ii, (element, element_parser) in enumerate(zip(elements, element_parsers)): if element_parser is coordinate: unit = self.coordinate_units[self.coordsys][ii % 2] coord_list.append(element_parser(element, unit)) elif self.coordinate_units[self.coordsys][0] is u.dimensionless_unscaled: coord_list.append(element_parser(element, unit=u.dimensionless_unscaled)) else: coord_list.append(element_parser(element)) if self.region_type in ['ellipse', 'box'] and len(coord_list) % 2 == 1: coord_list[-1] = CoordinateParser.parse_angular_length_quantity(elements[len(coord_list)-1]) # Reset iterator for ellipse and annulus # Note that this cannot be done with copy.deepcopy on python2 if self.region_type in ['ellipse', 'annulus']: self.language_spec[self.region_type] = itertools.chain( (coordinate, coordinate), itertools.cycle((radius,))) self.coord = coord_list def convert_meta(self): """ Convert meta string to dict """ meta_ = DS9Parser.parse_meta(self.meta_str) self.meta = copy.deepcopy(self.global_meta) self.meta.update(meta_) # the 'include' is not part of the metadata string; # it is pre-parsed as part of the shape type and should always # override the global one self.include = self.meta.get('include', True) if self.include == '' else self.include != '-' self.meta['include'] = self.include def make_shape(self): """ Make shape object """ # In DS9, ellipse can also represents an elliptical annulus # For elliptical annulus angle is optional. if self.region_type == 'ellipse': self.coord[2:] = [x * 2 for x in self.coord[2:]] if len(self.coord) % 2 == 1: # This checks if angle is present self.coord[-1] /= 2 if 'point' in self.meta: point = self.meta['point'].split(" ") if len(point) > 1: self.meta['symsize'] = point[1] self.meta['point'] = valid_symbols_ds9[point[0]] if 'font' in self.meta: fonts = self.meta['font'].split(" ") keys = ['font', 'fontsize', 'fontstyle', 'fontweight'] for i, val in enumerate(fonts): self.meta[keys[i]] = val self.meta.pop('coord', None) self.shape = Shape(coordsys=self.coordsys, region_type=reg_mapping['DS9'][self.region_type], coord=self.coord, meta=self.meta, composite=self.composite, include=self.include, ) regions-0.4/regions/io/ds9/setup_package.py0000644000076600000240000000025413477731541021042 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst def get_package_data(): parser_test = ['data/*.reg'] return {'regions.io.ds9.tests': parser_test} regions-0.4/regions/io/ds9/tests/0000755000076600000240000000000013501657425017012 5ustar deilstaff00000000000000regions-0.4/regions/io/ds9/tests/__init__.py0000644000076600000240000000000013336761120021103 0ustar deilstaff00000000000000regions-0.4/regions/io/ds9/tests/data/0000755000076600000240000000000013501657425017723 5ustar deilstaff00000000000000regions-0.4/regions/io/ds9/tests/data/ds9.color.reg0000644000076600000240000000106613336761120022233 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 fk5 circle(13:29:52.675,+47:11:45.02,1") # color=blue circle(13:29:52.675,+47:11:45.02,2") # color=#800 circle(13:29:52.675,+47:11:45.02,3") # color=#0a0 circle(13:29:52.675,+47:11:45.02,4") # color=#880000 circle(13:29:52.675,+47:11:45.02,5") # color=#00aa00 circle(13:29:52.675,+47:11:45.02,6") # color=#888800000000 circle(13:29:52.675,+47:11:45.02,7") # color=#0000aaaa0000 regions-0.4/regions/io/ds9/tests/data/ds9.color.spaces.reg0000644000076600000240000000110413336761120023501 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 fk5 circle(13:29:52.675, +47:11:45.02, 1") # color=blue circle(13:29:52.675, +47:11:45.02, 2") # color=#800 circle(13:29:52.675, +47:11:45.02, 3") # color=#0a0 circle(13:29:52.675, +47:11:45.02, 4") # color=#880000 circle(13:29:52.675, +47:11:45.02, 5") # color=#00aa00 circle(13:29:52.675, +47:11:45.02, 6") # color=#888800000000 circle(13:29:52.675, +47:11:45.02, 7") # color=#0000aaaa0000 regions-0.4/regions/io/ds9/tests/data/ds9.comment.reg0000644000076600000240000000016013336761120022551 0ustar deilstaff00000000000000# Region file format: DS9 version 4.0 # # foobar # foobar+ # foo+bar ## foobar ### foobar #. foobar ##. foobar regions-0.4/regions/io/ds9/tests/data/ds9.composite.reg0000644000076600000240000001006513336761120023116 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 fk5 # composite(202.48165,47.1931,317.39831) || composite=1 circle(202.48705,47.208237,3.9640007") || # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(202.48309,47.204492,7.9280014",3.9640007",2.3983109) || # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(202.47783,47.201057,15.856003",7.9280014",2.3983109) || # color=yellow font="helvetica 10 bold roman" text={Box} polygon(202.47309,47.198922,202.46877,47.199044,202.46859,47.196108,202.47291,47.195985) || # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(202.4684,47.194116,202.46202,47.193946) || # line=1 1 color=cyan text={Line} # vector(202.46159,47.191504,7.9280014",2.3983109) || vector=1 color=red text={Vector} # text(202.45907,47.188886) || color=magenta font="helvetica 14 bold roman" text={Region} # ruler(202.48176,47.194165,202.47471,47.194171) || ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(202.49319,47.203697,1.9820003",3.9640007",5.946001") || # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(202.48834,47.200368,2.9730005",1.4865003",5.946001",2.9730005",2.3983109) || # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(202.4832,47.197085,7.9280014",3.9640007",11.892002",5.946001",2.3983109) || # font="helvetica 10 bold roman" text={Box Annulus} point(202.49871,47.200189) || # point=circle text={Circle Point} point(202.49351,47.196791) || # point=box color=red width=3 text={Box Point} point(202.48857,47.193854) || # point=diamond text={Diamond Point} point(202.5005,47.197643) || # point=cross color=blue text={Cross Point} point(202.49591,47.194852) || # point=x text={X Point} point(202.49148,47.191862) || # point=arrow color=magenta text={Arrow Point} point(202.49864,47.19267) || # point=boxcircle text={BoxCircle Point} # projection(202.47611,47.189884,202.46694,47.189092,3.9640007") || text={Projection} panda(202.48266,47.190165,317.39831,587.39831,3,0",5.946001",2) || # text={Panda} panda(202.48753,47.186403,8.9802109,47.398311,1,0",2.9730005",1) || # panda=(8.9802109 47.398311 137.39831 227.39831)(0" 2.9730005" 5.946001") text={Panda 2} panda(202.48753,47.186403,8.9802109,47.398311,1,2.9730005",5.946001",1) || # panda=ignore panda(202.48753,47.186403,47.398311,137.39831,1,0",2.9730005",1) || # panda=ignore panda(202.48753,47.186403,47.398311,137.39831,1,2.9730005",5.946001",1) || # panda=ignore panda(202.48753,47.186403,137.39831,227.39831,1,0",2.9730005",1) || # panda=ignore panda(202.48753,47.186403,137.39831,227.39831,1,2.9730005",5.946001",1) || # panda=ignore # compass(202.46768,47.186188,7.9280014") || compass=physical {N} {E} 1 1 text={Compass} epanda(202.47821,47.186785,317.39831,587.39831,3,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983109) || # text={Epanda} epanda(202.48291,47.183066,2.3983109,47.398311,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983109) || # epanda=(2.3983109 47.398311 137.39831 227.39831)(2.9730005" 1.4865003" 5.946001" 2.9730005")(2.3983109) text={Epanda 2} epanda(202.48291,47.183066,47.398311,137.39831,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983109) || # epanda=ignore epanda(202.48291,47.183066,137.39831,227.39831,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983109) || # epanda=ignore bpanda(202.47302,47.183543,317.39831,587.39831,3,7.9280014",3.9640007",11.892002",5.946001",1,2.3983109) || # text={Bpanda} bpanda(202.47809,47.180126,2.3983109,47.398311,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983109) # bpanda=(2.3983109 47.398311 137.39831 227.39831)(7.9280014" 3.9640007" 11.892002" 5.946001")(2.3983109) text={Bpanda 2} bpanda(202.47809,47.180126,47.398311,137.39831,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983109) # bpanda=ignore bpanda(202.47809,47.180126,137.39831,227.39831,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983109) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.ecliptic.hms.reg0000644000076600000240000001003113336761120023467 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 ecliptic circle(+175:06:44.660,+50:57:09.921,3.964") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(+175:06:44.660,+50:56:53.323,7.928",3.964",326.717) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(+175:06:39.530,+50:56:35.776,15.856",7.928",326.717) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(+175:06:31.722,+50:56:22.779,+175:06:17.685,+50:56:16.970,+175:06:26.903,+50:56:08.125,+175:06:40.939,+50:56:13.934) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(+175:06:32.927,+50:56:02.026,+175:06:13.393,+50:55:52.432) # line=1 1 color=cyan text={Line} # vector(+175:06:20.154,+50:55:44.667,7.928",326.717) vector=1 color=red text={Vector} # text(+175:06:20.956,+50:55:33.430) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(+175:07:14.900,+50:56:21.236,+175:06:52.643,+50:56:11.190) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(+175:07:19.163,+50:57:05.414,1.982",3.964",5.946") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(+175:07:14.964,+50:56:48.757,2.973",1.4865",5.946",2.973",326.717) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(+175:07:09.715,+50:56:31.833,7.928",3.964",11.892",5.946",326.717) # font="helvetica 10 bold roman" text={Box Annulus} point(+175:07:48.259,+50:57:03.028) # point=circle text={Circle Point} point(+175:07:43.186,+50:56:45.675) # point=box color=red width=3 text={Box Point} point(+175:07:37.393,+50:56:30.037) # point=diamond text={Diamond Point} point(+175:08:02.394,+50:56:58.143) # point=cross color=blue text={Cross Point} point(+175:07:57.227,+50:56:43.435) # point=x text={X Point} point(+175:07:53.228,+50:56:28.371) # point=arrow color=magenta text={Arrow Point} point(+175:08:13.115,+50:56:40.951) # point=boxcircle text={BoxCircle Point} # projection(+175:07:11.338,+50:56:00.651,+175:06:45.077,+50:55:45.258,3.964") text={Projection} panda(+175:07:31.067,+50:56:10.824,281.717,551.717,3,0",5.946",2) # text={Panda} panda(+175:07:58.962,+50:56:06.771,333.299,371.717,1,0",2.973",1) # panda=(333.299 11.7173 101.717 191.717)(0" 2.973" 5.946") text={Panda 2} panda(+175:07:58.962,+50:56:06.771,333.299,371.717,1,2.973",5.946",1) # panda=ignore panda(+175:07:58.962,+50:56:06.771,11.7173,101.717,1,0",2.973",1) # panda=ignore panda(+175:07:58.962,+50:56:06.771,11.7173,101.717,1,2.973",5.946",1) # panda=ignore panda(+175:07:58.962,+50:56:06.771,101.717,191.717,1,0",2.973",1) # panda=ignore panda(+175:07:58.962,+50:56:06.771,101.717,191.717,1,2.973",5.946",1) # panda=ignore # compass(+175:06:57.081,+50:55:37.819,7.928") compass=physical {N} {E} 1 1 text={Compass} epanda(+175:07:28.292,+50:55:54.588,281.717,551.717,3,2.973",1.4865",5.946",2.973",1,326.717) # text={Epanda} epanda(+175:07:55.505,+50:55:50.422,326.717,371.717,1,2.973",1.4865",5.946",2.973",1,326.717) # epanda=(326.717 11.7173 101.717 191.717)(2.973" 1.4865" 5.946" 2.973")(326.717) text={Epanda 2} epanda(+175:07:55.505,+50:55:50.422,11.7173,101.717,1,2.973",1.4865",5.946",2.973",1,326.717) # epanda=ignore epanda(+175:07:55.505,+50:55:50.422,101.717,191.717,1,2.973",1.4865",5.946",2.973",1,326.717) # epanda=ignore bpanda(+175:07:22.735,+50:55:37.704,281.717,551.717,3,7.928",3.964",11.892",5.946",1,326.717) # text={Bpanda} bpanda(+175:07:50.085,+50:55:34.937,326.717,371.717,1,7.928",3.964",11.892",5.946",1,326.717) # bpanda=(326.717 11.7173 101.717 191.717)(7.928" 3.964" 11.892" 5.946")(326.717) text={Bpanda 2} bpanda(+175:07:50.085,+50:55:34.937,11.7173,101.717,1,7.928",3.964",11.892",5.946",1,326.717) # bpanda=ignore bpanda(+175:07:50.085,+50:55:34.937,101.717,191.717,1,7.928",3.964",11.892",5.946",1,326.717) # bpanda=ignore # segment(+175:06:02.705,+50:55:33.587,+175:06:14.128,+50:55:29.262,+175:06:12.470,+50:55:24.216) text={Segment} regions-0.4/regions/io/ds9/tests/data/ds9.ecliptic.hms.strip.reg0000644000076600000240000000377513336761120024650 0ustar deilstaff00000000000000ecliptic;circle(+175:06:44.660,+50:57:09.921,3.964");-ellipse(+175:06:44.660,+50:56:53.323,7.928",3.964",326.717);-box(+175:06:39.530,+50:56:35.776,15.856",7.928",326.717);polygon(+175:06:31.722,+50:56:22.779,+175:06:17.685,+50:56:16.970,+175:06:26.903,+50:56:08.125,+175:06:40.939,+50:56:13.934);-line(+175:06:32.927,+50:56:02.026,+175:06:13.393,+50:55:52.432);annulus(+175:07:19.163,+50:57:05.414,1.982",3.964",5.946");ellipse(+175:07:14.964,+50:56:48.757,2.973",1.4865",5.946",2.973",326.717);box(+175:07:09.715,+50:56:31.833,7.928",3.964",11.892",5.946",326.717);point(+175:07:48.259,+50:57:03.028);point(+175:07:43.186,+50:56:45.675);point(+175:07:37.393,+50:56:30.037);point(+175:08:02.394,+50:56:58.143);point(+175:07:57.227,+50:56:43.435);point(+175:07:53.228,+50:56:28.371);point(+175:08:13.115,+50:56:40.951);panda(+175:07:31.067,+50:56:10.824,281.717,551.717,3,0",5.946",2);panda(+175:07:58.962,+50:56:06.771,333.299,371.717,1,0",2.973",1);panda(+175:07:58.962,+50:56:06.771,333.299,371.717,1,2.973",5.946",1);panda(+175:07:58.962,+50:56:06.771,11.7173,101.717,1,0",2.973",1);panda(+175:07:58.962,+50:56:06.771,11.7173,101.717,1,2.973",5.946",1);panda(+175:07:58.962,+50:56:06.771,101.717,191.717,1,0",2.973",1);panda(+175:07:58.962,+50:56:06.771,101.717,191.717,1,2.973",5.946",1);epanda(+175:07:28.292,+50:55:54.588,281.717,551.717,3,2.973",1.4865",5.946",2.973",1,326.717);epanda(+175:07:55.505,+50:55:50.422,326.717,371.717,1,2.973",1.4865",5.946",2.973",1,326.717);epanda(+175:07:55.505,+50:55:50.422,11.7173,101.717,1,2.973",1.4865",5.946",2.973",1,326.717);epanda(+175:07:55.505,+50:55:50.422,101.717,191.717,1,2.973",1.4865",5.946",2.973",1,326.717);bpanda(+175:07:22.735,+50:55:37.704,281.717,551.717,3,7.928",3.964",11.892",5.946",1,326.717);bpanda(+175:07:50.085,+50:55:34.937,326.717,371.717,1,7.928",3.964",11.892",5.946",1,326.717);bpanda(+175:07:50.085,+50:55:34.937,11.7173,101.717,1,7.928",3.964",11.892",5.946",1,326.717);bpanda(+175:07:50.085,+50:55:34.937,101.717,191.717,1,7.928",3.964",11.892",5.946",1,326.717);regions-0.4/regions/io/ds9/tests/data/ds9.ecliptic.reg0000644000076600000240000000776413336761120022724 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 ecliptic circle(175.11241,50.952756,3.9640007") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(175.11241,50.948145,7.9280014",3.9640007",326.71725) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(175.11098,50.943271,15.856003",7.9280014",326.71725) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(175.10881,50.939661,175.10491,50.938047,175.10747,50.93559,175.11137,50.937204) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(175.10915,50.933896,175.10372,50.931231) # line=1 1 color=cyan text={Line} # vector(175.1056,50.929074,7.9280014",326.71725) vector=1 color=red text={Vector} # text(175.10582,50.925953) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(175.12081,50.939232,175.11462,50.936442) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(175.12199,50.951504,1.9820003",3.9640007",5.946001") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(175.12082,50.946877,2.9730005",1.4865003",5.946001",2.9730005",326.71725) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(175.11937,50.942176,7.9280014",3.9640007",11.892002",5.946001",326.71725) # font="helvetica 10 bold roman" text={Box Annulus} point(175.13007,50.950841) # point=circle text={Circle Point} point(175.12866,50.946021) # point=box color=red width=3 text={Box Point} point(175.12705,50.941677) # point=diamond text={Diamond Point} point(175.134,50.949484) # point=cross color=blue text={Cross Point} point(175.13256,50.945398) # point=x text={X Point} point(175.13145,50.941214) # point=arrow color=magenta text={Arrow Point} point(175.13698,50.944709) # point=boxcircle text={BoxCircle Point} # projection(175.11982,50.933514,175.11252,50.929238,3.9640007") text={Projection} panda(175.1253,50.93634,281.71725,551.71725,3,0",5.946001",2) # text={Panda} panda(175.13305,50.935214,333.29915,371.71725,1,0",2.9730005",1) # panda=(333.29915 11.717254 101.71725 191.71725)(0" 2.9730005" 5.946001") text={Panda 2} panda(175.13305,50.935214,333.29915,371.71725,1,2.9730005",5.946001",1) # panda=ignore panda(175.13305,50.935214,11.717254,101.71725,1,0",2.9730005",1) # panda=ignore panda(175.13305,50.935214,11.717254,101.71725,1,2.9730005",5.946001",1) # panda=ignore panda(175.13305,50.935214,101.71725,191.71725,1,0",2.9730005",1) # panda=ignore panda(175.13305,50.935214,101.71725,191.71725,1,2.9730005",5.946001",1) # panda=ignore # compass(175.11586,50.927172,7.9280014") compass=physical {N} {E} 1 1 text={Compass} epanda(175.12453,50.93183,281.71725,551.71725,3,2.9730005",1.4865003",5.946001",2.9730005",1,326.71725) # text={Epanda} epanda(175.13208,50.930673,326.71725,371.71725,1,2.9730005",1.4865003",5.946001",2.9730005",1,326.71725) # epanda=(326.71725 11.717254 101.71725 191.71725)(2.9730005" 1.4865003" 5.946001" 2.9730005")(326.71725) text={Epanda 2} epanda(175.13208,50.930673,11.717254,101.71725,1,2.9730005",1.4865003",5.946001",2.9730005",1,326.71725) # epanda=ignore epanda(175.13208,50.930673,101.71725,191.71725,1,2.9730005",1.4865003",5.946001",2.9730005",1,326.71725) # epanda=ignore bpanda(175.12298,50.92714,281.71725,551.71725,3,7.9280014",3.9640007",11.892002",5.946001",1,326.71725) # text={Bpanda} bpanda(175.13058,50.926371,326.71725,371.71725,1,7.9280014",3.9640007",11.892002",5.946001",1,326.71725) # bpanda=(326.71725 11.717254 101.71725 191.71725)(7.9280014" 3.9640007" 11.892002" 5.946001")(326.71725) text={Bpanda 2} bpanda(175.13058,50.926371,11.717254,101.71725,1,7.9280014",3.9640007",11.892002",5.946001",1,326.71725) # bpanda=ignore bpanda(175.13058,50.926371,101.71725,191.71725,1,7.9280014",3.9640007",11.892002",5.946001",1,326.71725) # bpanda=ignore # segment(175.10075,50.925996,175.10392,50.924795,175.10346,50.923393) text={Segment} regions-0.4/regions/io/ds9/tests/data/ds9.ecliptic.strip.reg0000644000076600000240000000374613336761120024060 0ustar deilstaff00000000000000ecliptic;circle(175.11241,50.952756,3.9640007");-ellipse(175.11241,50.948145,7.9280014",3.9640007",326.71725);-box(175.11098,50.943271,15.856003",7.9280014",326.71725);polygon(175.10881,50.939661,175.10491,50.938047,175.10747,50.93559,175.11137,50.937204);-line(175.10915,50.933896,175.10372,50.931231);annulus(175.12199,50.951504,1.9820003",3.9640007",5.946001");ellipse(175.12082,50.946877,2.9730005",1.4865003",5.946001",2.9730005",326.71725);box(175.11937,50.942176,7.9280014",3.9640007",11.892002",5.946001",326.71725);point(175.13007,50.950841);point(175.12866,50.946021);point(175.12705,50.941677);point(175.134,50.949484);point(175.13256,50.945398);point(175.13145,50.941214);point(175.13698,50.944709);panda(175.1253,50.93634,281.71725,551.71725,3,0",5.946001",2);panda(175.13305,50.935214,333.29915,371.71725,1,0",2.9730005",1);panda(175.13305,50.935214,333.29915,371.71725,1,2.9730005",5.946001",1);panda(175.13305,50.935214,11.717254,101.71725,1,0",2.9730005",1);panda(175.13305,50.935214,11.717254,101.71725,1,2.9730005",5.946001",1);panda(175.13305,50.935214,101.71725,191.71725,1,0",2.9730005",1);panda(175.13305,50.935214,101.71725,191.71725,1,2.9730005",5.946001",1);epanda(175.12453,50.93183,281.71725,551.71725,3,2.9730005",1.4865003",5.946001",2.9730005",1,326.71725);epanda(175.13208,50.930673,326.71725,371.71725,1,2.9730005",1.4865003",5.946001",2.9730005",1,326.71725);epanda(175.13208,50.930673,11.717254,101.71725,1,2.9730005",1.4865003",5.946001",2.9730005",1,326.71725);epanda(175.13208,50.930673,101.71725,191.71725,1,2.9730005",1.4865003",5.946001",2.9730005",1,326.71725);bpanda(175.12298,50.92714,281.71725,551.71725,3,7.9280014",3.9640007",11.892002",5.946001",1,326.71725);bpanda(175.13058,50.926371,326.71725,371.71725,1,7.9280014",3.9640007",11.892002",5.946001",1,326.71725);bpanda(175.13058,50.926371,11.717254,101.71725,1,7.9280014",3.9640007",11.892002",5.946001",1,326.71725);bpanda(175.13058,50.926371,101.71725,191.71725,1,7.9280014",3.9640007",11.892002",5.946001",1,326.71725);regions-0.4/regions/io/ds9/tests/data/ds9.fits.reg0000644000076600000240000000067013336761120022062 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 physical circle(383,1153,40) box(679,1149,160,80,0) -box(1057,1155,160,80,30) box(675,979,160,80,0) box(1065,979,160,80,30) -ellipse(399,777,80,40,30) point(687,773) # point=boxcircle annulus(685,561,20,60) polygon(1014,805,1151,805,1151,668,1051,685) regions-0.4/regions/io/ds9/tests/data/ds9.fk4.hms.reg0000644000076600000240000000762013336761120022371 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 fk4 circle(13:27:50.384,+47:27:57.76,3.964") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(13:27:49.426,+47:27:44.31,7.928",3.964",2.55413) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(13:27:48.154,+47:27:31.98,15.856",7.928",2.55413) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(13:27:47.011,+47:27:24.32,13:27:45.968,+47:27:24.79,13:27:45.922,+47:27:14.22,13:27:46.964,+47:27:13.75) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(13:27:45.873,+47:27:07.05,13:27:44.336,+47:27:06.48) # line=1 1 color=cyan text={Line} # vector(13:27:44.228,+47:26:57.70,7.928",2.55413) vector=1 color=red text={Vector} # text(13:27:43.620,+47:26:48.29) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(13:27:49.096,+47:27:07.14,13:27:47.395,+47:27:07.21) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(13:27:51.861,+47:27:41.38,1.982",3.964",5.946") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(13:27:50.688,+47:27:29.43,2.973",1.4865",5.946",2.973",2.55413) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(13:27:49.447,+47:27:17.65,7.928",3.964",11.892",5.946",2.55413) # font="helvetica 10 bold roman" text={Box Annulus} point(13:27:53.189,+47:27:28.71) # point=circle text={Circle Point} point(13:27:51.931,+47:27:16.52) # point=box color=red width=3 text={Box Point} point(13:27:50.737,+47:27:05.98) # point=diamond text={Diamond Point} point(13:27:53.618,+47:27:19.54) # point=cross color=blue text={Cross Point} point(13:27:52.509,+47:27:09.52) # point=x text={X Point} point(13:27:51.438,+47:26:58.79) # point=arrow color=magenta text={Arrow Point} point(13:27:53.166,+47:27:01.65) # point=boxcircle text={BoxCircle Point} # projection(13:27:47.729,+47:26:51.77,13:27:45.517,+47:26:48.98,3.964") text={Projection} panda(13:27:49.309,+47:26:52.74,317.554,587.554,3,0",5.946",2) # text={Panda} panda(13:27:50.481,+47:26:39.16,9.13603,47.5541,1,0",2.973",1) # panda=(9.13603 47.5541 137.554 227.554)(0" 2.973" 5.946") text={Panda 2} panda(13:27:50.481,+47:26:39.16,9.13603,47.5541,1,2.973",5.946",1) # panda=ignore panda(13:27:50.481,+47:26:39.16,47.5541,137.554,1,0",2.973",1) # panda=ignore panda(13:27:50.481,+47:26:39.16,47.5541,137.554,1,2.973",5.946",1) # panda=ignore panda(13:27:50.481,+47:26:39.16,137.554,227.554,1,0",2.973",1) # panda=ignore panda(13:27:50.481,+47:26:39.16,137.554,227.554,1,2.973",5.946",1) # panda=ignore # compass(13:27:45.693,+47:26:38.52,7.928") compass=physical {N} {E} 1 1 text={Compass} epanda(13:27:48.233,+47:26:40.60,317.554,587.554,3,2.973",1.4865",5.946",2.973",1,2.55413) # text={Epanda} epanda(13:27:49.363,+47:26:27.18,2.55413,47.5541,1,2.973",1.4865",5.946",2.973",1,2.55413) # epanda=(2.55413 47.5541 137.554 227.554)(2.973" 1.4865" 5.946" 2.973")(2.55413) text={Epanda 2} epanda(13:27:49.363,+47:26:27.18,47.5541,137.554,1,2.973",1.4865",5.946",2.973",1,2.55413) # epanda=ignore epanda(13:27:49.363,+47:26:27.18,137.554,227.554,1,2.973",1.4865",5.946",2.973",1,2.55413) # epanda=ignore bpanda(13:27:46.979,+47:26:28.96,317.554,587.554,3,7.928",3.964",11.892",5.946",1,2.55413) # text={Bpanda} bpanda(13:27:48.197,+47:26:16.63,2.55413,47.5541,1,7.928",3.964",11.892",5.946",1,2.55413) # bpanda=(2.55413 47.5541 137.554 227.554)(7.928" 3.964" 11.892" 5.946")(2.55413) text={Bpanda 2} bpanda(13:27:48.197,+47:26:16.63,47.5541,137.554,1,7.928",3.964",11.892",5.946",1,2.55413) # bpanda=ignore bpanda(13:27:48.197,+47:26:16.63,137.554,227.554,1,7.928",3.964",11.892",5.946",1,2.55413) # bpanda=ignore # segment(13:27:42.709,+47:26:55.15,13:27:43.035,+47:26:47.43,13:27:42.661,+47:26:43.95) text={Segment} regions-0.4/regions/io/ds9/tests/data/ds9.fk4.hms.strip.reg0000644000076600000240000000362213336761120023527 0ustar deilstaff00000000000000fk4;circle(13:27:50.384,+47:27:57.76,3.964");-ellipse(13:27:49.426,+47:27:44.31,7.928",3.964",2.55413);-box(13:27:48.154,+47:27:31.98,15.856",7.928",2.55413);polygon(13:27:47.011,+47:27:24.32,13:27:45.968,+47:27:24.79,13:27:45.922,+47:27:14.22,13:27:46.964,+47:27:13.75);-line(13:27:45.873,+47:27:07.05,13:27:44.336,+47:27:06.48);annulus(13:27:51.861,+47:27:41.38,1.982",3.964",5.946");ellipse(13:27:50.688,+47:27:29.43,2.973",1.4865",5.946",2.973",2.55413);box(13:27:49.447,+47:27:17.65,7.928",3.964",11.892",5.946",2.55413);point(13:27:53.189,+47:27:28.71);point(13:27:51.931,+47:27:16.52);point(13:27:50.737,+47:27:05.98);point(13:27:53.618,+47:27:19.54);point(13:27:52.509,+47:27:09.52);point(13:27:51.438,+47:26:58.79);point(13:27:53.166,+47:27:01.65);panda(13:27:49.309,+47:26:52.74,317.554,587.554,3,0",5.946",2);panda(13:27:50.481,+47:26:39.16,9.13603,47.5541,1,0",2.973",1);panda(13:27:50.481,+47:26:39.16,9.13603,47.5541,1,2.973",5.946",1);panda(13:27:50.481,+47:26:39.16,47.5541,137.554,1,0",2.973",1);panda(13:27:50.481,+47:26:39.16,47.5541,137.554,1,2.973",5.946",1);panda(13:27:50.481,+47:26:39.16,137.554,227.554,1,0",2.973",1);panda(13:27:50.481,+47:26:39.16,137.554,227.554,1,2.973",5.946",1);epanda(13:27:48.233,+47:26:40.60,317.554,587.554,3,2.973",1.4865",5.946",2.973",1,2.55413);epanda(13:27:49.363,+47:26:27.18,2.55413,47.5541,1,2.973",1.4865",5.946",2.973",1,2.55413);epanda(13:27:49.363,+47:26:27.18,47.5541,137.554,1,2.973",1.4865",5.946",2.973",1,2.55413);epanda(13:27:49.363,+47:26:27.18,137.554,227.554,1,2.973",1.4865",5.946",2.973",1,2.55413);bpanda(13:27:46.979,+47:26:28.96,317.554,587.554,3,7.928",3.964",11.892",5.946",1,2.55413);bpanda(13:27:48.197,+47:26:16.63,2.55413,47.5541,1,7.928",3.964",11.892",5.946",1,2.55413);bpanda(13:27:48.197,+47:26:16.63,47.5541,137.554,1,7.928",3.964",11.892",5.946",1,2.55413);bpanda(13:27:48.197,+47:26:16.63,137.554,227.554,1,7.928",3.964",11.892",5.946",1,2.55413);regions-0.4/regions/io/ds9/tests/data/ds9.fk4.reg0000644000076600000240000000776213336761120021612 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 fk4 circle(201.95993,47.466046,3.9640007") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(201.95594,47.462308,7.9280014",3.9640007",2.5541322) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(201.95064,47.458883,15.856003",7.9280014",2.5541322) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(201.94588,47.456757,201.94153,47.456887,201.94134,47.453951,201.94568,47.45382) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(201.94114,47.45196,201.93473,47.451801) # line=1 1 color=cyan text={Line} # vector(201.93428,47.44936,7.9280014",2.5541322) vector=1 color=red text={Vector} # text(201.93175,47.446747) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(201.95457,47.451984,201.94748,47.452003) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(201.96609,47.461495,1.9820003",3.9640007",5.946001") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(201.9612,47.458175,2.9730005",1.4865003",5.946001",2.9730005",2.5541322) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(201.95603,47.454902,7.9280014",3.9640007",11.892002",5.946001",2.5541322) # font="helvetica 10 bold roman" text={Box Annulus} point(201.97162,47.457976) # point=circle text={Circle Point} point(201.96638,47.454589) # point=box color=red width=3 text={Box Point} point(201.9614,47.451661) # point=diamond text={Diamond Point} point(201.97341,47.455428) # point=cross color=blue text={Cross Point} point(201.96879,47.452645) # point=x text={X Point} point(201.96433,47.449663) # point=arrow color=magenta text={Arrow Point} point(201.97152,47.450458) # point=boxcircle text={BoxCircle Point} # projection(201.94887,47.447713,201.93966,47.446938,3.9640007") text={Projection} panda(201.95546,47.447982,317.55413,587.55413,3,0",5.946001",2) # text={Panda} panda(201.96034,47.444211,9.1360322,47.554132,1,0",2.9730005",1) # panda=(9.1360322 47.554132 137.55413 227.55413)(0" 2.9730005" 5.946001") text={Panda 2} panda(201.96034,47.444211,9.1360322,47.554132,1,2.9730005",5.946001",1) # panda=ignore panda(201.96034,47.444211,47.554132,137.55413,1,0",2.9730005",1) # panda=ignore panda(201.96034,47.444211,47.554132,137.55413,1,2.9730005",5.946001",1) # panda=ignore panda(201.96034,47.444211,137.55413,227.55413,1,0",2.9730005",1) # panda=ignore panda(201.96034,47.444211,137.55413,227.55413,1,2.9730005",5.946001",1) # panda=ignore # compass(201.94039,47.444033,7.9280014") compass=physical {N} {E} 1 1 text={Compass} epanda(201.95097,47.444611,317.55413,587.55413,3,2.9730005",1.4865003",5.946001",2.9730005",1,2.5541322) # text={Epanda} epanda(201.95568,47.440883,2.5541322,47.554132,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.5541322) # epanda=(2.5541322 47.554132 137.55413 227.55413)(2.9730005" 1.4865003" 5.946001" 2.9730005")(2.5541322) text={Epanda 2} epanda(201.95568,47.440883,47.554132,137.55413,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.5541322) # epanda=ignore epanda(201.95568,47.440883,137.55413,227.55413,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.5541322) # epanda=ignore bpanda(201.94574,47.441378,317.55413,587.55413,3,7.9280014",3.9640007",11.892002",5.946001",1,2.5541322) # text={Bpanda} bpanda(201.95082,47.437951,2.5541322,47.554132,1,7.9280014",3.9640007",11.892002",5.946001",1,2.5541322) # bpanda=(2.5541322 47.554132 137.55413 227.55413)(7.9280014" 3.9640007" 11.892002" 5.946001")(2.5541322) text={Bpanda 2} bpanda(201.95082,47.437951,47.554132,137.55413,1,7.9280014",3.9640007",11.892002",5.946001",1,2.5541322) # bpanda=ignore bpanda(201.95082,47.437951,137.55413,227.55413,1,7.9280014",3.9640007",11.892002",5.946001",1,2.5541322) # bpanda=ignore # segment(201.92796,47.448653,201.92931,47.446508,201.92775,47.445542) text={Segment} regions-0.4/regions/io/ds9/tests/data/ds9.fk4.strip.reg0000644000076600000240000000374413336761120022746 0ustar deilstaff00000000000000fk4;circle(201.95993,47.466046,3.9640007");-ellipse(201.95594,47.462308,7.9280014",3.9640007",2.5541322);-box(201.95064,47.458883,15.856003",7.9280014",2.5541322);polygon(201.94588,47.456757,201.94153,47.456887,201.94134,47.453951,201.94568,47.45382);-line(201.94114,47.45196,201.93473,47.451801);annulus(201.96609,47.461495,1.9820003",3.9640007",5.946001");ellipse(201.9612,47.458175,2.9730005",1.4865003",5.946001",2.9730005",2.5541322);box(201.95603,47.454902,7.9280014",3.9640007",11.892002",5.946001",2.5541322);point(201.97162,47.457976);point(201.96638,47.454589);point(201.9614,47.451661);point(201.97341,47.455428);point(201.96879,47.452645);point(201.96433,47.449663);point(201.97152,47.450458);panda(201.95546,47.447982,317.55413,587.55413,3,0",5.946001",2);panda(201.96034,47.444211,9.1360322,47.554132,1,0",2.9730005",1);panda(201.96034,47.444211,9.1360322,47.554132,1,2.9730005",5.946001",1);panda(201.96034,47.444211,47.554132,137.55413,1,0",2.9730005",1);panda(201.96034,47.444211,47.554132,137.55413,1,2.9730005",5.946001",1);panda(201.96034,47.444211,137.55413,227.55413,1,0",2.9730005",1);panda(201.96034,47.444211,137.55413,227.55413,1,2.9730005",5.946001",1);epanda(201.95097,47.444611,317.55413,587.55413,3,2.9730005",1.4865003",5.946001",2.9730005",1,2.5541322);epanda(201.95568,47.440883,2.5541322,47.554132,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.5541322);epanda(201.95568,47.440883,47.554132,137.55413,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.5541322);epanda(201.95568,47.440883,137.55413,227.55413,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.5541322);bpanda(201.94574,47.441378,317.55413,587.55413,3,7.9280014",3.9640007",11.892002",5.946001",1,2.5541322);bpanda(201.95082,47.437951,2.5541322,47.554132,1,7.9280014",3.9640007",11.892002",5.946001",1,2.5541322);bpanda(201.95082,47.437951,47.554132,137.55413,1,7.9280014",3.9640007",11.892002",5.946001",1,2.5541322);bpanda(201.95082,47.437951,137.55413,227.55413,1,7.9280014",3.9640007",11.892002",5.946001",1,2.5541322);regions-0.4/regions/io/ds9/tests/data/ds9.fk5.hms.reg0000644000076600000240000000762013336761120022372 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 fk5 circle(13:29:56.743,+47:12:30.42,3.964") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(13:29:55.792,+47:12:16.94,7.928",3.964",2.39831) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(13:29:54.530,+47:12:04.57,15.856",7.928",2.39831) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(13:29:53.394,+47:11:56.88,13:29:52.357,+47:11:57.32,13:29:52.314,+47:11:46.75,13:29:53.351,+47:11:46.31) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(13:29:52.267,+47:11:39.58,13:29:50.737,+47:11:38.97) # line=1 1 color=cyan text={Line} # vector(13:29:50.632,+47:11:30.18,7.928",2.39831) vector=1 color=red text={Vector} # text(13:29:50.030,+47:11:20.75) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(13:29:55.474,+47:11:39.76,13:29:53.782,+47:11:39.78) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(13:29:58.217,+47:12:14.07,1.982",3.964",5.946") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(13:29:57.053,+47:12:02.09,2.973",1.4865",5.946",2.973",2.39831) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(13:29:55.820,+47:11:50.27,7.928",3.964",11.892",5.946",2.39831) # font="helvetica 10 bold roman" text={Box Annulus} point(13:29:59.541,+47:12:01.44) # point=circle text={Circle Point} point(13:29:58.293,+47:11:49.21) # point=box color=red width=3 text={Box Point} point(13:29:57.107,+47:11:38.64) # point=diamond text={Diamond Point} point(13:29:59.971,+47:11:52.28) # point=cross color=blue text={Cross Point} point(13:29:58.870,+47:11:42.23) # point=x text={X Point} point(13:29:57.807,+47:11:31.47) # point=arrow color=magenta text={Arrow Point} point(13:29:59.526,+47:11:34.38) # point=boxcircle text={BoxCircle Point} # projection(13:29:54.118,+47:11:24.35,13:29:51.918,+47:11:21.50,3.964") text={Projection} panda(13:29:55.690,+47:11:25.36,317.398,587.398,3,0",5.946",2) # text={Panda} panda(13:29:56.859,+47:11:11.81,8.98021,47.3983,1,0",2.973",1) # panda=(8.98021 47.3983 137.398 227.398)(0" 2.973" 5.946") text={Panda 2} panda(13:29:56.859,+47:11:11.81,8.98021,47.3983,1,2.973",5.946",1) # panda=ignore panda(13:29:56.859,+47:11:11.81,47.3983,137.398,1,0",2.973",1) # panda=ignore panda(13:29:56.859,+47:11:11.81,47.3983,137.398,1,2.973",5.946",1) # panda=ignore panda(13:29:56.859,+47:11:11.81,137.398,227.398,1,0",2.973",1) # panda=ignore panda(13:29:56.859,+47:11:11.81,137.398,227.398,1,2.973",5.946",1) # panda=ignore # compass(13:29:52.095,+47:11:11.04,7.928") compass=physical {N} {E} 1 1 text={Compass} epanda(13:29:54.622,+47:11:13.19,317.398,587.398,3,2.973",1.4865",5.946",2.973",1,2.39831) # text={Epanda} epanda(13:29:55.750,+47:10:59.80,2.39831,47.3983,1,2.973",1.4865",5.946",2.973",1,2.39831) # epanda=(2.39831 47.3983 137.398 227.398)(2.973" 1.4865" 5.946" 2.973")(2.39831) text={Epanda 2} epanda(13:29:55.750,+47:10:59.80,47.3983,137.398,1,2.973",1.4865",5.946",2.973",1,2.39831) # epanda=ignore epanda(13:29:55.750,+47:10:59.80,137.398,227.398,1,2.973",1.4865",5.946",2.973",1,2.39831) # epanda=ignore bpanda(13:29:53.377,+47:11:01.52,317.398,587.398,3,7.928",3.964",11.892",5.946",1,2.39831) # text={Bpanda} bpanda(13:29:54.593,+47:10:49.22,2.39831,47.3983,1,7.928",3.964",11.892",5.946",1,2.39831) # bpanda=(2.39831 47.3983 137.398 227.398)(7.928" 3.964" 11.892" 5.946")(2.39831) text={Bpanda 2} bpanda(13:29:54.593,+47:10:49.22,47.3983,137.398,1,7.928",3.964",11.892",5.946",1,2.39831) # bpanda=ignore bpanda(13:29:54.593,+47:10:49.22,137.398,227.398,1,7.928",3.964",11.892",5.946",1,2.39831) # bpanda=ignore # segment(13:29:49.122,+47:11:27.59,13:29:49.448,+47:11:19.88,13:29:49.076,+47:11:16.39) text={Segment} regions-0.4/regions/io/ds9/tests/data/ds9.fk5.hms.strip.reg0000644000076600000240000000362213336761120023530 0ustar deilstaff00000000000000fk5;circle(13:29:56.743,+47:12:30.42,3.964");-ellipse(13:29:55.792,+47:12:16.94,7.928",3.964",2.39831);-box(13:29:54.530,+47:12:04.57,15.856",7.928",2.39831);polygon(13:29:53.394,+47:11:56.88,13:29:52.357,+47:11:57.32,13:29:52.314,+47:11:46.75,13:29:53.351,+47:11:46.31);-line(13:29:52.267,+47:11:39.58,13:29:50.737,+47:11:38.97);annulus(13:29:58.217,+47:12:14.07,1.982",3.964",5.946");ellipse(13:29:57.053,+47:12:02.09,2.973",1.4865",5.946",2.973",2.39831);box(13:29:55.820,+47:11:50.27,7.928",3.964",11.892",5.946",2.39831);point(13:29:59.541,+47:12:01.44);point(13:29:58.293,+47:11:49.21);point(13:29:57.107,+47:11:38.64);point(13:29:59.971,+47:11:52.28);point(13:29:58.870,+47:11:42.23);point(13:29:57.807,+47:11:31.47);point(13:29:59.526,+47:11:34.38);panda(13:29:55.690,+47:11:25.36,317.398,587.398,3,0",5.946",2);panda(13:29:56.859,+47:11:11.81,8.98021,47.3983,1,0",2.973",1);panda(13:29:56.859,+47:11:11.81,8.98021,47.3983,1,2.973",5.946",1);panda(13:29:56.859,+47:11:11.81,47.3983,137.398,1,0",2.973",1);panda(13:29:56.859,+47:11:11.81,47.3983,137.398,1,2.973",5.946",1);panda(13:29:56.859,+47:11:11.81,137.398,227.398,1,0",2.973",1);panda(13:29:56.859,+47:11:11.81,137.398,227.398,1,2.973",5.946",1);epanda(13:29:54.622,+47:11:13.19,317.398,587.398,3,2.973",1.4865",5.946",2.973",1,2.39831);epanda(13:29:55.750,+47:10:59.80,2.39831,47.3983,1,2.973",1.4865",5.946",2.973",1,2.39831);epanda(13:29:55.750,+47:10:59.80,47.3983,137.398,1,2.973",1.4865",5.946",2.973",1,2.39831);epanda(13:29:55.750,+47:10:59.80,137.398,227.398,1,2.973",1.4865",5.946",2.973",1,2.39831);bpanda(13:29:53.377,+47:11:01.52,317.398,587.398,3,7.928",3.964",11.892",5.946",1,2.39831);bpanda(13:29:54.593,+47:10:49.22,2.39831,47.3983,1,7.928",3.964",11.892",5.946",1,2.39831);bpanda(13:29:54.593,+47:10:49.22,47.3983,137.398,1,7.928",3.964",11.892",5.946",1,2.39831);bpanda(13:29:54.593,+47:10:49.22,137.398,227.398,1,7.928",3.964",11.892",5.946",1,2.39831);regions-0.4/regions/io/ds9/tests/data/ds9.fk5.reg0000644000076600000240000000776013336761120021611 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 fk5 circle(202.48643,47.208449,3.9640007") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(202.48247,47.204704,7.9280014",3.9640007",2.3983109) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(202.47721,47.201269,15.856003",7.9280014",2.3983109) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(202.47248,47.199134,202.46815,47.199257,202.46797,47.19632,202.4723,47.196197) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(202.46778,47.194329,202.4614,47.194158) # line=1 1 color=cyan text={Line} # vector(202.46097,47.191716,7.9280014",2.3983109) vector=1 color=red text={Vector} # text(202.45846,47.189099) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(202.48114,47.194378,202.47409,47.194383) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(202.49257,47.20391,1.9820003",3.9640007",5.946001") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(202.48772,47.20058,2.9730005",1.4865003",5.946001",2.9730005",2.3983109) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(202.48258,47.197298,7.9280014",3.9640007",11.892002",5.946001",2.3983109) # font="helvetica 10 bold roman" text={Box Annulus} point(202.49809,47.200401) # point=circle text={Circle Point} point(202.49289,47.197004) # point=box color=red width=3 text={Box Point} point(202.48795,47.194067) # point=diamond text={Diamond Point} point(202.49988,47.197856) # point=cross color=blue text={Cross Point} point(202.49529,47.195065) # point=x text={X Point} point(202.49086,47.192074) # point=arrow color=magenta text={Arrow Point} point(202.49802,47.192883) # point=boxcircle text={BoxCircle Point} # projection(202.47549,47.190096,202.46632,47.189304,3.9640007") text={Projection} panda(202.48204,47.190378,317.39831,587.39831,3,0",5.946001",2) # text={Panda} panda(202.48691,47.186615,8.9802109,47.398311,1,0",2.9730005",1) # panda=(8.9802109 47.398311 137.39831 227.39831)(0" 2.9730005" 5.946001") text={Panda 2} panda(202.48691,47.186615,8.9802109,47.398311,1,2.9730005",5.946001",1) # panda=ignore panda(202.48691,47.186615,47.398311,137.39831,1,0",2.9730005",1) # panda=ignore panda(202.48691,47.186615,47.398311,137.39831,1,2.9730005",5.946001",1) # panda=ignore panda(202.48691,47.186615,137.39831,227.39831,1,0",2.9730005",1) # panda=ignore panda(202.48691,47.186615,137.39831,227.39831,1,2.9730005",5.946001",1) # panda=ignore # compass(202.46706,47.1864,7.9280014") compass=physical {N} {E} 1 1 text={Compass} epanda(202.47759,47.186997,317.39831,587.39831,3,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983109) # text={Epanda} epanda(202.48229,47.183279,2.3983109,47.398311,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983109) # epanda=(2.3983109 47.398311 137.39831 227.39831)(2.9730005" 1.4865003" 5.946001" 2.9730005")(2.3983109) text={Epanda 2} epanda(202.48229,47.183279,47.398311,137.39831,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983109) # epanda=ignore epanda(202.48229,47.183279,137.39831,227.39831,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983109) # epanda=ignore bpanda(202.47241,47.183755,317.39831,587.39831,3,7.9280014",3.9640007",11.892002",5.946001",1,2.3983109) # text={Bpanda} bpanda(202.47747,47.180338,2.3983109,47.398311,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983109) # bpanda=(2.3983109 47.398311 137.39831 227.39831)(7.9280014" 3.9640007" 11.892002" 5.946001")(2.3983109) text={Bpanda 2} bpanda(202.47747,47.180338,47.398311,137.39831,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983109) # bpanda=ignore bpanda(202.47747,47.180338,137.39831,227.39831,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983109) # bpanda=ignore # segment(202.45467,47.190998,202.45603,47.188855,202.45448,47.187886) text={Segment} regions-0.4/regions/io/ds9/tests/data/ds9.fk5.strip.reg0000644000076600000240000000374313336761120022746 0ustar deilstaff00000000000000fk5;circle(202.48643,47.208449,3.9640007");-ellipse(202.48247,47.204704,7.9280014",3.9640007",2.3983109);-box(202.47721,47.201269,15.856003",7.9280014",2.3983109);polygon(202.47248,47.199134,202.46815,47.199257,202.46797,47.19632,202.4723,47.196197);-line(202.46778,47.194329,202.4614,47.194158);annulus(202.49257,47.20391,1.9820003",3.9640007",5.946001");ellipse(202.48772,47.20058,2.9730005",1.4865003",5.946001",2.9730005",2.3983109);box(202.48258,47.197298,7.9280014",3.9640007",11.892002",5.946001",2.3983109);point(202.49809,47.200401);point(202.49289,47.197004);point(202.48795,47.194067);point(202.49988,47.197856);point(202.49529,47.195065);point(202.49086,47.192074);point(202.49802,47.192883);panda(202.48204,47.190378,317.39831,587.39831,3,0",5.946001",2);panda(202.48691,47.186615,8.9802109,47.398311,1,0",2.9730005",1);panda(202.48691,47.186615,8.9802109,47.398311,1,2.9730005",5.946001",1);panda(202.48691,47.186615,47.398311,137.39831,1,0",2.9730005",1);panda(202.48691,47.186615,47.398311,137.39831,1,2.9730005",5.946001",1);panda(202.48691,47.186615,137.39831,227.39831,1,0",2.9730005",1);panda(202.48691,47.186615,137.39831,227.39831,1,2.9730005",5.946001",1);epanda(202.47759,47.186997,317.39831,587.39831,3,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983109);epanda(202.48229,47.183279,2.3983109,47.398311,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983109);epanda(202.48229,47.183279,47.398311,137.39831,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983109);epanda(202.48229,47.183279,137.39831,227.39831,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983109);bpanda(202.47241,47.183755,317.39831,587.39831,3,7.9280014",3.9640007",11.892002",5.946001",1,2.3983109);bpanda(202.47747,47.180338,2.3983109,47.398311,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983109);bpanda(202.47747,47.180338,47.398311,137.39831,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983109);bpanda(202.47747,47.180338,137.39831,227.39831,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983109);regions-0.4/regions/io/ds9/tests/data/ds9.galactic.hms.reg0000644000076600000240000001003113336761120023442 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 galactic circle(+104:50:15.532,+68:32:38.380,3.964") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(+104:50:24.720,+68:32:54.634,7.928",3.964",158.389) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(+104:50:43.097,+68:33:11.163,15.856",7.928",158.389) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(+104:51:03.480,+68:33:22.893,+104:51:30.395,+68:33:26.787,+104:51:19.743,+68:33:36.626,+104:50:52.826,+68:33:32.732) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(+104:51:12.957,+68:33:43.369,+104:51:51.267,+68:33:50.265) # line=1 1 color=cyan text={Line} # vector(+104:51:44.162,+68:33:58.733,7.928",158.389) vector=1 color=red text={Vector} # text(+104:51:49.050,+68:34:09.839) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(+104:49:51.449,+68:33:29.913,+104:50:34.587,+68:33:36.913) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(+104:49:19.827,+68:32:47.191,1.982",3.964",5.946") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(+104:49:36.118,+68:33:02.969,2.973",1.4865",5.946",2.973",158.389) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(+104:49:54.339,+68:33:18.875,7.928",3.964",11.892",5.946",158.389) # font="helvetica 10 bold roman" text={Box Annulus} point(+104:48:32.059,+68:32:53.230) # point=circle text={Circle Point} point(+104:48:50.197,+68:33:09.580) # point=box color=red width=3 text={Box Point} point(+104:49:08.613,+68:33:24.159) # point=diamond text={Diamond Point} point(+104:48:10.904,+68:32:59.810) # point=cross color=blue text={Cross Point} point(+104:48:27.737,+68:33:13.560) # point=x text={X Point} point(+104:48:42.801,+68:33:27.806) # point=arrow color=magenta text={Arrow Point} point(+104:48:02.289,+68:33:18.011) # point=boxcircle text={BoxCircle Point} # projection(+104:50:08.859,+68:33:49.619,+104:51:01.742,+68:34:01.341,3.964") text={Projection} panda(+104:49:29.913,+68:33:42.170,113.389,383.389,3,0",5.946",2) # text={Panda} panda(+104:48:45.044,+68:33:49.690,164.971,203.389,1,0",2.973",1) # panda=(164.971 203.389 293.389 23.3893)(0" 2.973" 5.946") text={Panda 2} panda(+104:48:45.044,+68:33:49.690,164.971,203.389,1,2.973",5.946",1) # panda=ignore panda(+104:48:45.044,+68:33:49.690,203.389,293.389,1,0",2.973",1) # panda=ignore panda(+104:48:45.044,+68:33:49.690,203.389,293.389,1,2.973",5.946",1) # panda=ignore panda(+104:48:45.044,+68:33:49.690,293.389,383.389,1,0",2.973",1) # panda=ignore panda(+104:48:45.044,+68:33:49.690,293.389,383.389,1,2.973",5.946",1) # panda=ignore # compass(+104:50:45.588,+68:34:10.159,7.928") compass=physical {N} {E} 1 1 text={Compass} epanda(+104:49:43.580,+68:33:57.717,113.389,383.389,3,2.973",1.4865",5.946",2.973",1,158.389) # text={Epanda} epanda(+104:48:59.915,+68:34:05.263,158.389,203.389,1,2.973",1.4865",5.946",2.973",1,158.389) # epanda=(158.389 203.389 293.389 23.3893)(2.973" 1.4865" 5.946" 2.973")(158.389) text={Epanda 2} epanda(+104:48:59.915,+68:34:05.263,203.389,293.389,1,2.973",1.4865",5.946",2.973",1,158.389) # epanda=ignore epanda(+104:48:59.915,+68:34:05.263,293.389,383.389,1,2.973",1.4865",5.946",2.973",1,158.389) # epanda=ignore bpanda(+104:50:02.312,+68:34:13.544,113.389,383.389,3,7.928",3.964",11.892",5.946",1,158.389) # text={Bpanda} bpanda(+104:49:17.632,+68:34:19.739,158.389,203.389,1,7.928",3.964",11.892",5.946",1,158.389) # bpanda=(158.389 203.389 293.389 23.3893)(7.928" 3.964" 11.892" 5.946")(158.389) text={Bpanda 2} bpanda(+104:49:17.632,+68:34:19.739,203.389,293.389,1,7.928",3.964",11.892",5.946",1,158.389) # bpanda=ignore bpanda(+104:49:17.632,+68:34:19.739,293.389,383.389,1,7.928",3.964",11.892",5.946",1,158.389) # bpanda=ignore # segment(+104:52:19.792,+68:34:07.349,+104:52:02.900,+68:34:13.047,+104:52:08.507,+68:34:17.775) text={Segment} regions-0.4/regions/io/ds9/tests/data/ds9.galactic.hms.strip.reg0000644000076600000240000000377513336761120024623 0ustar deilstaff00000000000000galactic;circle(+104:50:15.532,+68:32:38.380,3.964");-ellipse(+104:50:24.720,+68:32:54.634,7.928",3.964",158.389);-box(+104:50:43.097,+68:33:11.163,15.856",7.928",158.389);polygon(+104:51:03.480,+68:33:22.893,+104:51:30.395,+68:33:26.787,+104:51:19.743,+68:33:36.626,+104:50:52.826,+68:33:32.732);-line(+104:51:12.957,+68:33:43.369,+104:51:51.267,+68:33:50.265);annulus(+104:49:19.827,+68:32:47.191,1.982",3.964",5.946");ellipse(+104:49:36.118,+68:33:02.969,2.973",1.4865",5.946",2.973",158.389);box(+104:49:54.339,+68:33:18.875,7.928",3.964",11.892",5.946",158.389);point(+104:48:32.059,+68:32:53.230);point(+104:48:50.197,+68:33:09.580);point(+104:49:08.613,+68:33:24.159);point(+104:48:10.904,+68:32:59.810);point(+104:48:27.737,+68:33:13.560);point(+104:48:42.801,+68:33:27.806);point(+104:48:02.289,+68:33:18.011);panda(+104:49:29.913,+68:33:42.170,113.389,383.389,3,0",5.946",2);panda(+104:48:45.044,+68:33:49.690,164.971,203.389,1,0",2.973",1);panda(+104:48:45.044,+68:33:49.690,164.971,203.389,1,2.973",5.946",1);panda(+104:48:45.044,+68:33:49.690,203.389,293.389,1,0",2.973",1);panda(+104:48:45.044,+68:33:49.690,203.389,293.389,1,2.973",5.946",1);panda(+104:48:45.044,+68:33:49.690,293.389,383.389,1,0",2.973",1);panda(+104:48:45.044,+68:33:49.690,293.389,383.389,1,2.973",5.946",1);epanda(+104:49:43.580,+68:33:57.717,113.389,383.389,3,2.973",1.4865",5.946",2.973",1,158.389);epanda(+104:48:59.915,+68:34:05.263,158.389,203.389,1,2.973",1.4865",5.946",2.973",1,158.389);epanda(+104:48:59.915,+68:34:05.263,203.389,293.389,1,2.973",1.4865",5.946",2.973",1,158.389);epanda(+104:48:59.915,+68:34:05.263,293.389,383.389,1,2.973",1.4865",5.946",2.973",1,158.389);bpanda(+104:50:02.312,+68:34:13.544,113.389,383.389,3,7.928",3.964",11.892",5.946",1,158.389);bpanda(+104:49:17.632,+68:34:19.739,158.389,203.389,1,7.928",3.964",11.892",5.946",1,158.389);bpanda(+104:49:17.632,+68:34:19.739,203.389,293.389,1,7.928",3.964",11.892",5.946",1,158.389);bpanda(+104:49:17.632,+68:34:19.739,293.389,383.389,1,7.928",3.964",11.892",5.946",1,158.389);regions-0.4/regions/io/ds9/tests/data/ds9.galactic.reg0000644000076600000240000000775713336761120022701 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 galactic circle(104.83765,68.543994,3.9640007") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(104.8402,68.54851,7.9280014",3.9640007",158.38935) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(104.8453,68.553101,15.856003",7.9280014",158.38935) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(104.85097,68.556359,104.85844,68.557441,104.85548,68.560174,104.84801,68.559092) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(104.8536,68.562047,104.86424,68.563963) # line=1 1 color=cyan text={Line} # vector(104.86227,68.566315,7.9280014",158.38935) vector=1 color=red text={Vector} # text(104.86363,68.5694) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(104.83096,68.558309,104.84294,68.560253) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(104.82217,68.546442,1.9820003",3.9640007",5.946001") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(104.8267,68.550825,2.9730005",1.4865003",5.946001",2.9730005",158.38935) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(104.83176,68.555243,7.9280014",3.9640007",11.892002",5.946001",158.38935) # font="helvetica 10 bold roman" text={Box Annulus} point(104.80891,68.548119) # point=circle text={Circle Point} point(104.81394,68.552661) # point=box color=red width=3 text={Box Point} point(104.81906,68.556711) # point=diamond text={Diamond Point} point(104.80303,68.549947) # point=cross color=blue text={Cross Point} point(104.8077,68.553767) # point=x text={X Point} point(104.81189,68.557724) # point=arrow color=magenta text={Arrow Point} point(104.80064,68.555003) # point=boxcircle text={BoxCircle Point} # projection(104.83579,68.563783,104.85048,68.567039,3.9640007") text={Projection} panda(104.82498,68.561714,113.38935,383.38935,3,0",5.946001",2) # text={Panda} panda(104.81251,68.563803,164.97125,203.38935,1,0",2.9730005",1) # panda=(164.97125 203.38935 293.38935 23.389346)(0" 2.9730005" 5.946001") text={Panda 2} panda(104.81251,68.563803,164.97125,203.38935,1,2.9730005",5.946001",1) # panda=ignore panda(104.81251,68.563803,203.38935,293.38935,1,0",2.9730005",1) # panda=ignore panda(104.81251,68.563803,203.38935,293.38935,1,2.9730005",5.946001",1) # panda=ignore panda(104.81251,68.563803,293.38935,383.38935,1,0",2.9730005",1) # panda=ignore panda(104.81251,68.563803,293.38935,383.38935,1,2.9730005",5.946001",1) # panda=ignore # compass(104.846,68.569488,7.9280014") compass=physical {N} {E} 1 1 text={Compass} epanda(104.82877,68.566033,113.38935,383.38935,3,2.9730005",1.4865003",5.946001",2.9730005",1,158.38935) # text={Epanda} epanda(104.81664,68.568129,158.38935,203.38935,1,2.9730005",1.4865003",5.946001",2.9730005",1,158.38935) # epanda=(158.38935 203.38935 293.38935 23.389346)(2.9730005" 1.4865003" 5.946001" 2.9730005")(158.38935) text={Epanda 2} epanda(104.81664,68.568129,203.38935,293.38935,1,2.9730005",1.4865003",5.946001",2.9730005",1,158.38935) # epanda=ignore epanda(104.81664,68.568129,293.38935,383.38935,1,2.9730005",1.4865003",5.946001",2.9730005",1,158.38935) # epanda=ignore bpanda(104.83398,68.570429,113.38935,383.38935,3,7.9280014",3.9640007",11.892002",5.946001",1,158.38935) # text={Bpanda} bpanda(104.82156,68.57215,158.38935,203.38935,1,7.9280014",3.9640007",11.892002",5.946001",1,158.38935) # bpanda=(158.38935 203.38935 293.38935 23.389346)(7.9280014" 3.9640007" 11.892002" 5.946001")(158.38935) text={Bpanda 2} bpanda(104.82156,68.57215,203.38935,293.38935,1,7.9280014",3.9640007",11.892002",5.946001",1,158.38935) # bpanda=ignore bpanda(104.82156,68.57215,293.38935,383.38935,1,7.9280014",3.9640007",11.892002",5.946001",1,158.38935) # bpanda=ignore # segment(104.87216,68.568708,104.86747,68.570291,104.86903,68.571604) text={Segment} regions-0.4/regions/io/ds9/tests/data/ds9.galactic.strip.reg0000644000076600000240000000374413336761120024031 0ustar deilstaff00000000000000galactic;circle(104.83765,68.543994,3.9640007");-ellipse(104.8402,68.54851,7.9280014",3.9640007",158.38935);-box(104.8453,68.553101,15.856003",7.9280014",158.38935);polygon(104.85097,68.556359,104.85844,68.557441,104.85548,68.560174,104.84801,68.559092);-line(104.8536,68.562047,104.86424,68.563963);annulus(104.82217,68.546442,1.9820003",3.9640007",5.946001");ellipse(104.8267,68.550825,2.9730005",1.4865003",5.946001",2.9730005",158.38935);box(104.83176,68.555243,7.9280014",3.9640007",11.892002",5.946001",158.38935);point(104.80891,68.548119);point(104.81394,68.552661);point(104.81906,68.556711);point(104.80303,68.549947);point(104.8077,68.553767);point(104.81189,68.557724);point(104.80064,68.555003);panda(104.82498,68.561714,113.38935,383.38935,3,0",5.946001",2);panda(104.81251,68.563803,164.97125,203.38935,1,0",2.9730005",1);panda(104.81251,68.563803,164.97125,203.38935,1,2.9730005",5.946001",1);panda(104.81251,68.563803,203.38935,293.38935,1,0",2.9730005",1);panda(104.81251,68.563803,203.38935,293.38935,1,2.9730005",5.946001",1);panda(104.81251,68.563803,293.38935,383.38935,1,0",2.9730005",1);panda(104.81251,68.563803,293.38935,383.38935,1,2.9730005",5.946001",1);epanda(104.82877,68.566033,113.38935,383.38935,3,2.9730005",1.4865003",5.946001",2.9730005",1,158.38935);epanda(104.81664,68.568129,158.38935,203.38935,1,2.9730005",1.4865003",5.946001",2.9730005",1,158.38935);epanda(104.81664,68.568129,203.38935,293.38935,1,2.9730005",1.4865003",5.946001",2.9730005",1,158.38935);epanda(104.81664,68.568129,293.38935,383.38935,1,2.9730005",1.4865003",5.946001",2.9730005",1,158.38935);bpanda(104.83398,68.570429,113.38935,383.38935,3,7.9280014",3.9640007",11.892002",5.946001",1,158.38935);bpanda(104.82156,68.57215,158.38935,203.38935,1,7.9280014",3.9640007",11.892002",5.946001",1,158.38935);bpanda(104.82156,68.57215,203.38935,293.38935,1,7.9280014",3.9640007",11.892002",5.946001",1,158.38935);bpanda(104.82156,68.57215,293.38935,383.38935,1,7.9280014",3.9640007",11.892002",5.946001",1,158.38935);regions-0.4/regions/io/ds9/tests/data/ds9.icrs.hms.reg0000644000076600000240000000762113336761120022646 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 icrs circle(13:29:56.743,+47:12:30.42,3.964") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(13:29:55.792,+47:12:16.94,7.928",3.964",2.39832) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(13:29:54.530,+47:12:04.57,15.856",7.928",2.39832) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(13:29:53.394,+47:11:56.88,13:29:52.357,+47:11:57.33,13:29:52.314,+47:11:46.75,13:29:53.351,+47:11:46.31) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(13:29:52.267,+47:11:39.58,13:29:50.737,+47:11:38.97) # line=1 1 color=cyan text={Line} # vector(13:29:50.632,+47:11:30.18,7.928",2.39832) vector=1 color=red text={Vector} # text(13:29:50.030,+47:11:20.76) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(13:29:55.474,+47:11:39.76,13:29:53.782,+47:11:39.78) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(13:29:58.217,+47:12:14.08,1.982",3.964",5.946") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(13:29:57.053,+47:12:02.09,2.973",1.4865",5.946",2.973",2.39832) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(13:29:55.820,+47:11:50.27,7.928",3.964",11.892",5.946",2.39832) # font="helvetica 10 bold roman" text={Box Annulus} point(13:29:59.541,+47:12:01.45) # point=circle text={Circle Point} point(13:29:58.293,+47:11:49.22) # point=box color=red width=3 text={Box Point} point(13:29:57.108,+47:11:38.64) # point=diamond text={Diamond Point} point(13:29:59.971,+47:11:52.28) # point=cross color=blue text={Cross Point} point(13:29:58.870,+47:11:42.24) # point=x text={X Point} point(13:29:57.807,+47:11:31.47) # point=arrow color=magenta text={Arrow Point} point(13:29:59.526,+47:11:34.38) # point=boxcircle text={BoxCircle Point} # projection(13:29:54.118,+47:11:24.35,13:29:51.918,+47:11:21.50,3.964") text={Projection} panda(13:29:55.691,+47:11:25.36,317.398,587.398,3,0",5.946",2) # text={Panda} panda(13:29:56.859,+47:11:11.82,8.98022,47.3983,1,0",2.973",1) # panda=(8.98022 47.3983 137.398 227.398)(0" 2.973" 5.946") text={Panda 2} panda(13:29:56.859,+47:11:11.82,8.98022,47.3983,1,2.973",5.946",1) # panda=ignore panda(13:29:56.859,+47:11:11.82,47.3983,137.398,1,0",2.973",1) # panda=ignore panda(13:29:56.859,+47:11:11.82,47.3983,137.398,1,2.973",5.946",1) # panda=ignore panda(13:29:56.859,+47:11:11.82,137.398,227.398,1,0",2.973",1) # panda=ignore panda(13:29:56.859,+47:11:11.82,137.398,227.398,1,2.973",5.946",1) # panda=ignore # compass(13:29:52.095,+47:11:11.04,7.928") compass=physical {N} {E} 1 1 text={Compass} epanda(13:29:54.622,+47:11:13.19,317.398,587.398,3,2.973",1.4865",5.946",2.973",1,2.39832) # text={Epanda} epanda(13:29:55.751,+47:10:59.81,2.39832,47.3983,1,2.973",1.4865",5.946",2.973",1,2.39832) # epanda=(2.39832 47.3983 137.398 227.398)(2.973" 1.4865" 5.946" 2.973")(2.39832) text={Epanda 2} epanda(13:29:55.751,+47:10:59.81,47.3983,137.398,1,2.973",1.4865",5.946",2.973",1,2.39832) # epanda=ignore epanda(13:29:55.751,+47:10:59.81,137.398,227.398,1,2.973",1.4865",5.946",2.973",1,2.39832) # epanda=ignore bpanda(13:29:53.377,+47:11:01.52,317.398,587.398,3,7.928",3.964",11.892",5.946",1,2.39832) # text={Bpanda} bpanda(13:29:54.593,+47:10:49.22,2.39832,47.3983,1,7.928",3.964",11.892",5.946",1,2.39832) # bpanda=(2.39832 47.3983 137.398 227.398)(7.928" 3.964" 11.892" 5.946")(2.39832) text={Bpanda 2} bpanda(13:29:54.593,+47:10:49.22,47.3983,137.398,1,7.928",3.964",11.892",5.946",1,2.39832) # bpanda=ignore bpanda(13:29:54.593,+47:10:49.22,137.398,227.398,1,7.928",3.964",11.892",5.946",1,2.39832) # bpanda=ignore # segment(13:29:49.122,+47:11:27.59,13:29:49.448,+47:11:19.88,13:29:49.076,+47:11:16.39) text={Segment} regions-0.4/regions/io/ds9/tests/data/ds9.icrs.hms.strip.reg0000644000076600000240000000362313336761120024004 0ustar deilstaff00000000000000icrs;circle(13:29:56.743,+47:12:30.42,3.964");-ellipse(13:29:55.792,+47:12:16.94,7.928",3.964",2.39832);-box(13:29:54.530,+47:12:04.57,15.856",7.928",2.39832);polygon(13:29:53.394,+47:11:56.88,13:29:52.357,+47:11:57.33,13:29:52.314,+47:11:46.75,13:29:53.351,+47:11:46.31);-line(13:29:52.267,+47:11:39.58,13:29:50.737,+47:11:38.97);annulus(13:29:58.217,+47:12:14.08,1.982",3.964",5.946");ellipse(13:29:57.053,+47:12:02.09,2.973",1.4865",5.946",2.973",2.39832);box(13:29:55.820,+47:11:50.27,7.928",3.964",11.892",5.946",2.39832);point(13:29:59.541,+47:12:01.45);point(13:29:58.293,+47:11:49.22);point(13:29:57.108,+47:11:38.64);point(13:29:59.971,+47:11:52.28);point(13:29:58.870,+47:11:42.24);point(13:29:57.807,+47:11:31.47);point(13:29:59.526,+47:11:34.38);panda(13:29:55.691,+47:11:25.36,317.398,587.398,3,0",5.946",2);panda(13:29:56.859,+47:11:11.82,8.98022,47.3983,1,0",2.973",1);panda(13:29:56.859,+47:11:11.82,8.98022,47.3983,1,2.973",5.946",1);panda(13:29:56.859,+47:11:11.82,47.3983,137.398,1,0",2.973",1);panda(13:29:56.859,+47:11:11.82,47.3983,137.398,1,2.973",5.946",1);panda(13:29:56.859,+47:11:11.82,137.398,227.398,1,0",2.973",1);panda(13:29:56.859,+47:11:11.82,137.398,227.398,1,2.973",5.946",1);epanda(13:29:54.622,+47:11:13.19,317.398,587.398,3,2.973",1.4865",5.946",2.973",1,2.39832);epanda(13:29:55.751,+47:10:59.81,2.39832,47.3983,1,2.973",1.4865",5.946",2.973",1,2.39832);epanda(13:29:55.751,+47:10:59.81,47.3983,137.398,1,2.973",1.4865",5.946",2.973",1,2.39832);epanda(13:29:55.751,+47:10:59.81,137.398,227.398,1,2.973",1.4865",5.946",2.973",1,2.39832);bpanda(13:29:53.377,+47:11:01.52,317.398,587.398,3,7.928",3.964",11.892",5.946",1,2.39832);bpanda(13:29:54.593,+47:10:49.22,2.39832,47.3983,1,7.928",3.964",11.892",5.946",1,2.39832);bpanda(13:29:54.593,+47:10:49.22,47.3983,137.398,1,7.928",3.964",11.892",5.946",1,2.39832);bpanda(13:29:54.593,+47:10:49.22,137.398,227.398,1,7.928",3.964",11.892",5.946",1,2.39832);regions-0.4/regions/io/ds9/tests/data/ds9.icrs.reg0000644000076600000240000000775013336761120022063 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 icrs circle(202.48643,47.208449,3.9640007") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(202.48247,47.204705,7.9280014",3.9640007",2.3983198) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(202.47721,47.20127,15.856003",7.9280014",2.3983198) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(202.47248,47.199135,202.46815,47.199257,202.46797,47.19632,202.4723,47.196198) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(202.46778,47.194329,202.4614,47.194159) # line=1 1 color=cyan text={Line} # vector(202.46097,47.191716,7.9280014",2.3983198) vector=1 color=red text={Vector} # text(202.45846,47.189099) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(202.48114,47.194378,202.47409,47.194384) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(202.49257,47.20391,1.9820003",3.9640007",5.946001") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(202.48772,47.200581,2.9730005",1.4865003",5.946001",2.9730005",2.3983198) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(202.48259,47.197298,7.9280014",3.9640007",11.892002",5.946001",2.3983198) # font="helvetica 10 bold roman" text={Box Annulus} point(202.49809,47.200401) # point=circle text={Circle Point} point(202.49289,47.197004) # point=box color=red width=3 text={Box Point} point(202.48795,47.194067) # point=diamond text={Diamond Point} point(202.49988,47.197856) # point=cross color=blue text={Cross Point} point(202.49529,47.195065) # point=x text={X Point} point(202.49086,47.192075) # point=arrow color=magenta text={Arrow Point} point(202.49802,47.192883) # point=boxcircle text={BoxCircle Point} # projection(202.47549,47.190097,202.46632,47.189305,3.9640007") text={Projection} panda(202.48204,47.190378,317.39832,587.39832,3,0",5.946001",2) # text={Panda} panda(202.48691,47.186615,8.9802198,47.39832,1,0",2.9730005",1) # panda=(8.9802198 47.39832 137.39832 227.39832)(0" 2.9730005" 5.946001") text={Panda 2} panda(202.48691,47.186615,8.9802198,47.39832,1,2.9730005",5.946001",1) # panda=ignore panda(202.48691,47.186615,47.39832,137.39832,1,0",2.9730005",1) # panda=ignore panda(202.48691,47.186615,47.39832,137.39832,1,2.9730005",5.946001",1) # panda=ignore panda(202.48691,47.186615,137.39832,227.39832,1,0",2.9730005",1) # panda=ignore panda(202.48691,47.186615,137.39832,227.39832,1,2.9730005",5.946001",1) # panda=ignore # compass(202.46706,47.186401,7.9280014") compass=physical {N} {E} 1 1 text={Compass} epanda(202.47759,47.186998,317.39832,587.39832,3,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983198) # text={Epanda} epanda(202.48229,47.183279,2.3983198,47.39832,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983198) # epanda=(2.3983198 47.39832 137.39832 227.39832)(2.9730005" 1.4865003" 5.946001" 2.9730005")(2.3983198) text={Epanda 2} epanda(202.48229,47.183279,47.39832,137.39832,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983198) # epanda=ignore epanda(202.48229,47.183279,137.39832,227.39832,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983198) # epanda=ignore bpanda(202.47241,47.183755,317.39832,587.39832,3,7.9280014",3.9640007",11.892002",5.946001",1,2.3983198) # text={Bpanda} bpanda(202.47747,47.180338,2.3983198,47.39832,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983198) # bpanda=(2.3983198 47.39832 137.39832 227.39832)(7.9280014" 3.9640007" 11.892002" 5.946001")(2.3983198) text={Bpanda 2} bpanda(202.47747,47.180338,47.39832,137.39832,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983198) # bpanda=ignore bpanda(202.47747,47.180338,137.39832,227.39832,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983198) # bpanda=ignore # segment(202.45468,47.190998,202.45603,47.188856,202.45448,47.187886) text={Segment} regions-0.4/regions/io/ds9/tests/data/ds9.icrs.strip.reg0000644000076600000240000000373413336761120023221 0ustar deilstaff00000000000000icrs;circle(202.48643,47.208449,3.9640007");-ellipse(202.48247,47.204705,7.9280014",3.9640007",2.3983198);-box(202.47721,47.20127,15.856003",7.9280014",2.3983198);polygon(202.47248,47.199135,202.46815,47.199257,202.46797,47.19632,202.4723,47.196198);-line(202.46778,47.194329,202.4614,47.194159);annulus(202.49257,47.20391,1.9820003",3.9640007",5.946001");ellipse(202.48772,47.200581,2.9730005",1.4865003",5.946001",2.9730005",2.3983198);box(202.48259,47.197298,7.9280014",3.9640007",11.892002",5.946001",2.3983198);point(202.49809,47.200401);point(202.49289,47.197004);point(202.48795,47.194067);point(202.49988,47.197856);point(202.49529,47.195065);point(202.49086,47.192075);point(202.49802,47.192883);panda(202.48204,47.190378,317.39832,587.39832,3,0",5.946001",2);panda(202.48691,47.186615,8.9802198,47.39832,1,0",2.9730005",1);panda(202.48691,47.186615,8.9802198,47.39832,1,2.9730005",5.946001",1);panda(202.48691,47.186615,47.39832,137.39832,1,0",2.9730005",1);panda(202.48691,47.186615,47.39832,137.39832,1,2.9730005",5.946001",1);panda(202.48691,47.186615,137.39832,227.39832,1,0",2.9730005",1);panda(202.48691,47.186615,137.39832,227.39832,1,2.9730005",5.946001",1);epanda(202.47759,47.186998,317.39832,587.39832,3,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983198);epanda(202.48229,47.183279,2.3983198,47.39832,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983198);epanda(202.48229,47.183279,47.39832,137.39832,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983198);epanda(202.48229,47.183279,137.39832,227.39832,1,2.9730005",1.4865003",5.946001",2.9730005",1,2.3983198);bpanda(202.47241,47.183755,317.39832,587.39832,3,7.9280014",3.9640007",11.892002",5.946001",1,2.3983198);bpanda(202.47747,47.180338,2.3983198,47.39832,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983198);bpanda(202.47747,47.180338,47.39832,137.39832,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983198);bpanda(202.47747,47.180338,137.39832,227.39832,1,7.9280014",3.9640007",11.892002",5.946001",1,2.3983198);regions-0.4/regions/io/ds9/tests/data/ds9.image.reg0000644000076600000240000000522113336761120022174 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 image circle(166,546,20) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(248,529,40,20,45) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(338,527,80,40,45) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(407.24723,538,445,575.75275,482.75277,538,445,500.24723) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(509,513,569,564) # line=1 1 color=cyan text={Line} # vector(603,535,40,45) vector=1 color=red text={Vector} # text(658,521) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(387,402,451,461) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(166,434,10,20,30) # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(251,430,15,7.5,30,15,45) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(338,429,40,20,60,30,45) # font="helvetica 10 bold roman" text={Box Annulus} point(159,341) # point=circle text={Circle Point} point(248,339) # point=box color=red width=3 text={Box Point} point(329,341) # point=diamond text={Diamond Point} point(174,292) # point=cross color=blue text={Cross Point} point(250,293) # point=x text={X Point} point(327,290) # point=arrow color=magenta text={Arrow Point} point(252,241) # point=boxcircle text={BoxCircle Point} # projection(491,392,584,458,20) text={Projection} panda(428,341,0,270,3,0,30,2) # text={Panda} panda(430,250,51.5819,90,1,0,15,1) # panda=(51.5819 90 180 270)(0 15 30) text={Panda 2} panda(430,250,51.5819,90,1,15,30,1) # panda=ignore panda(430,250,90,180,1,0,15,1) # panda=ignore panda(430,250,90,180,1,15,30,1) # panda=ignore panda(430,250,180,270,1,0,15,1) # panda=ignore panda(430,250,180,270,1,15,30,1) # panda=ignore # compass(613,413,40) compass=physical {N} {E} 1 1 text={Compass} epanda(510,333,0,270,3,15,7.5,30,15,1,45) # text={Epanda} epanda(513,244,45,90,1,15,7.5,30,15,1,45) # epanda=(45 90 180 270)(15 7.5 30 15)(45) text={Epanda 2} epanda(513,244,90,180,1,15,7.5,30,15,1,45) # epanda=ignore epanda(513,244,180,270,1,15,7.5,30,15,1,45) # epanda=ignore bpanda(597,333,0,270,3,40,20,60,30,1,45) # text={Bpanda} bpanda(593,245,45,90,1,40,20,60,30,1,45) # bpanda=(45 90 180 270)(40 20 60 30)(45) text={Bpanda 2} bpanda(593,245,90,180,1,40,20,60,30,1,45) # bpanda=ignore bpanda(593,245,180,270,1,40,20,60,30,1,45) # bpanda=ignore # segment(668.9973,577.99654,682.99709,537.99647,708.99709,537.99633) text={Segment} regions-0.4/regions/io/ds9/tests/data/ds9.image.strip.reg0000644000076600000240000000163213336761120023336 0ustar deilstaff00000000000000image;circle(166,546,20);-ellipse(248,529,40,20,45);-box(338,527,80,40,45);polygon(407.24723,538,445,575.75275,482.75277,538,445,500.24723);-line(509,513,569,564);annulus(166,434,10,20,30);ellipse(251,430,15,7.5,30,15,45);box(338,429,40,20,60,30,45);point(159,341);point(248,339);point(329,341);point(174,292);point(250,293);point(327,290);point(252,241);panda(428,341,0,270,3,0,30,2);panda(430,250,51.5819,90,1,0,15,1);panda(430,250,51.5819,90,1,15,30,1);panda(430,250,90,180,1,0,15,1);panda(430,250,90,180,1,15,30,1);panda(430,250,180,270,1,0,15,1);panda(430,250,180,270,1,15,30,1);epanda(510,333,0,270,3,15,7.5,30,15,1,45);epanda(513,244,45,90,1,15,7.5,30,15,1,45);epanda(513,244,90,180,1,15,7.5,30,15,1,45);epanda(513,244,180,270,1,15,7.5,30,15,1,45);bpanda(597,333,0,270,3,40,20,60,30,1,45);bpanda(593,245,45,90,1,40,20,60,30,1,45);bpanda(593,245,90,180,1,40,20,60,30,1,45);bpanda(593,245,180,270,1,40,20,60,30,1,45);regions-0.4/regions/io/ds9/tests/data/ds9.linear.wcs.reg0000644000076600000240000001335513336761120023166 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 wcs; # tile 2 circle(3975,3969,40) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 2 -ellipse(3811,3935,80,40,135) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 2 -box(3631,3931,160,80,135) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 2 polygon(3492.5055,3953,3417,4028.5055,3341.4945,3953,3417,3877.4945) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 2 -line(3289,3903,3169,4005) # line=1 1 color=cyan text={Line} # tile 2 # vector(3101,3947,80,135) vector=1 color=red text={Vector} # tile 2 # text(2991,3919) color=magenta font="helvetica 14 bold roman" text={Region} # tile 2 # ruler(3533,3681,3405,3799) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 2 annulus(3975,3745,20,40,60) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 2 ellipse(3805,3737,30,15,60,30,135) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 2 box(3631,3735,80,40,120,60,135) # font="helvetica 10 bold roman" text={Box Annulus} # tile 2 point(3989,3559) # point=circle text={Circle Point} # tile 2 point(3811,3555) # point=box color=red width=3 text={Box Point} # tile 2 point(3649,3559) # point=diamond text={Diamond Point} # tile 2 point(3959,3461) # point=cross color=blue text={Cross Point} # tile 2 point(3807,3463) # point=x text={X Point} # tile 2 point(3653,3457) # point=arrow color=magenta text={Arrow Point} # tile 2 point(3803,3359) # point=boxcircle text={BoxCircle Point} # tile 2 # projection(3325,3661,3139,3793,40) text={Projection} # tile 2 panda(3451,3559,180,270,3,0,60,2) # text={Panda} # tile 2 panda(3447,3377,128.4181,450,1,0,30,1) # panda=(128.4181 90 0 270)(0 30 60) text={Panda 2} # tile 2 panda(3447,3377,128.4181,450,1,30,60,1) # panda=ignore # tile 2 panda(3447,3377,90,360,1,0,30,1) # panda=ignore # tile 2 panda(3447,3377,90,360,1,30,60,1) # panda=ignore # tile 2 panda(3447,3377,0,270,1,0,30,1) # panda=ignore # tile 2 panda(3447,3377,0,270,1,30,60,1) # panda=ignore # tile 2 # compass(3081,3703,80) compass=physical {N} {E} 1 1 text={Compass} # tile 2 epanda(3287,3543,180,270,3,30,15,60,30,1,135) # text={Epanda} # tile 2 epanda(3281,3365,135,450,1,30,15,60,30,1,135) # epanda=(135 90 0 270)(30 15 60 30)(135) text={Epanda 2} # tile 2 epanda(3281,3365,90,360,1,30,15,60,30,1,135) # epanda=ignore # tile 2 epanda(3281,3365,0,270,1,30,15,60,30,1,135) # epanda=ignore # tile 2 bpanda(3113,3543,180,270,3,80,40,120,60,1,135) # text={Bpanda} # tile 2 bpanda(3121,3367,135,450,1,80,40,120,60,1,135) # bpanda=(135 90 0 270)(80 40 120 60)(135) text={Bpanda 2} # tile 2 bpanda(3121,3367,90,360,1,80,40,120,60,1,135) # bpanda=ignore # tile 2 bpanda(3121,3367,0,270,1,80,40,120,60,1,135) # bpanda=ignore # tile 7 circle(5027,4773,40) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 7 -ellipse(4863,4739,80,40,135) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 7 -box(4683,4735,160,80,135) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 7 polygon(4544.5055,4757,4469,4832.5055,4393.4945,4757,4469,4681.4945) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 7 -line(4341,4707,4221,4809) # line=1 1 color=cyan text={Line} # tile 7 # vector(4153,4751,80,135) vector=1 color=red text={Vector} # tile 6 # text(4043,4723) color=magenta font="helvetica 14 bold roman" text={Region} # tile 7 # ruler(4585,4485,4457,4603) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 7 annulus(5027,4549,20,40,60) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 7 ellipse(4857,4541,30,15,60,30,135) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 7 box(4683,4539,80,40,120,60,135) # font="helvetica 10 bold roman" text={Box Annulus} # tile 7 point(5041,4363) # point=circle text={Circle Point} # tile 7 point(4863,4359) # point=box color=red width=3 text={Box Point} # tile 7 point(4701,4363) # point=diamond text={Diamond Point} # tile 7 point(5011,4265) # point=cross color=blue text={Cross Point} # tile 7 point(4859,4267) # point=x text={X Point} # tile 7 point(4705,4261) # point=arrow color=magenta text={Arrow Point} # tile 7 point(4855,4163) # point=boxcircle text={BoxCircle Point} # tile 7 # projection(4377,4465,4191,4597,40) text={Projection} # tile 7 panda(4503,4363,180,270,3,0,60,2) # text={Panda} # tile 7 panda(4499,4181,128.4181,450,1,0,30,1) # panda=(128.4181 90 0 270)(0 30 60) text={Panda 2} # tile 7 panda(4499,4181,128.4181,450,1,30,60,1) # panda=ignore # tile 7 panda(4499,4181,90,360,1,0,30,1) # panda=ignore # tile 7 panda(4499,4181,90,360,1,30,60,1) # panda=ignore # tile 7 panda(4499,4181,0,270,1,0,30,1) # panda=ignore # tile 7 panda(4499,4181,0,270,1,30,60,1) # panda=ignore # tile 7 # compass(4133,4507,80) compass=physical {N} {E} 1 1 text={Compass} # tile 7 epanda(4339,4347,180,270,3,30,15,60,30,1,135) # text={Epanda} # tile 7 epanda(4333,4169,135,450,1,30,15,60,30,1,135) # epanda=(135 90 0 270)(30 15 60 30)(135) text={Epanda 2} # tile 7 epanda(4333,4169,90,360,1,30,15,60,30,1,135) # epanda=ignore # tile 7 epanda(4333,4169,0,270,1,30,15,60,30,1,135) # epanda=ignore # tile 7 bpanda(4165,4347,180,270,3,80,40,120,60,1,135) # text={Bpanda} # tile 7 bpanda(4173,4171,135,450,1,80,40,120,60,1,135) # bpanda=(135 90 0 270)(80 40 120 60)(135) text={Bpanda 2} # tile 7 bpanda(4173,4171,90,360,1,80,40,120,60,1,135) # bpanda=ignore # tile 7 bpanda(4173,4171,0,270,1,80,40,120,60,1,135) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.linear.wcsa.reg0000644000076600000240000001365413336761120023331 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 wcsa; # tile 2 circle(121.5,3969.5,40) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 2 -ellipse(285.5,3935.5,80,40,45) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 2 -box(465.5,3931.5,160,80,45) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 2 polygon(603.9945,3953.5,679.5,4029.0055,755.0055,3953.5,679.5,3877.9945) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 2 -line(807.5,3903.5,927.5,4005.5) # line=1 1 color=cyan text={Line} # tile 2 # vector(995.5,3947.5,80,45) vector=1 color=red text={Vector} # tile 2 # text(1105.5,3919.5) color=magenta font="helvetica 14 bold roman" text={Region} # tile 2 # ruler(563.5,3681.5,691.5,3799.5) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 2 annulus(121.5,3745.5,20,40,60) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 2 ellipse(291.5,3737.5,30,15,60,30,45) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 2 box(465.5,3735.5,80,40,120,60,45) # font="helvetica 10 bold roman" text={Box Annulus} # tile 2 point(107.5,3559.5) # point=circle text={Circle Point} # tile 2 point(285.5,3555.5) # point=box color=red width=3 text={Box Point} # tile 2 point(447.5,3559.5) # point=diamond text={Diamond Point} # tile 2 point(137.5,3461.5) # point=cross color=blue text={Cross Point} # tile 2 point(289.5,3463.5) # point=x text={X Point} # tile 2 point(443.5,3457.5) # point=arrow color=magenta text={Arrow Point} # tile 2 point(293.5,3359.5) # point=boxcircle text={BoxCircle Point} # tile 2 # projection(771.5,3661.5,957.5,3793.5,40) text={Projection} # tile 2 panda(645.5,3559.5,0,270,3,0,60,2) # text={Panda} # tile 2 panda(649.5,3377.5,51.5819,90,1,0,30,1) # panda=(51.5819 90 180 270)(0 30 60) text={Panda 2} # tile 2 panda(649.5,3377.5,51.5819,90,1,30,60,1) # panda=ignore # tile 2 panda(649.5,3377.5,90,180,1,0,30,1) # panda=ignore # tile 2 panda(649.5,3377.5,90,180,1,30,60,1) # panda=ignore # tile 2 panda(649.5,3377.5,180,270,1,0,30,1) # panda=ignore # tile 2 panda(649.5,3377.5,180,270,1,30,60,1) # panda=ignore # tile 2 # compass(1015.5,3703.5,80) compass=physical {N} {E} 1 1 text={Compass} # tile 2 epanda(809.5,3543.5,0,270,3,30,15,60,30,1,45) # text={Epanda} # tile 2 epanda(815.5,3365.5,45,90,1,30,15,60,30,1,45) # epanda=(45 90 180 270)(30 15 60 30)(45) text={Epanda 2} # tile 2 epanda(815.5,3365.5,90,180,1,30,15,60,30,1,45) # epanda=ignore # tile 2 epanda(815.5,3365.5,180,270,1,30,15,60,30,1,45) # epanda=ignore # tile 2 bpanda(983.5,3543.5,0,270,3,80,40,120,60,1,45) # text={Bpanda} # tile 2 bpanda(975.5,3367.5,45,90,1,80,40,120,60,1,45) # bpanda=(45 90 180 270)(80 40 120 60)(45) text={Bpanda 2} # tile 2 bpanda(975.5,3367.5,90,180,1,80,40,120,60,1,45) # bpanda=ignore # tile 2 bpanda(975.5,3367.5,180,270,1,80,40,120,60,1,45) # bpanda=ignore # tile 7 circle(931.5,3419.5,40) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 7 -ellipse(767.5,3453.5,80,40,45) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 7 -box(587.5,3457.5,160,80,45) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 7 polygon(449.0055,3435.5,373.5,3359.9945,297.9945,3435.5,373.5,3511.0055) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 7 -line(245.5,3485.5,125.5,3383.5) # line=1 1 color=cyan text={Line} # tile 7 # vector(57.5,3441.5,80,45) vector=1 color=red text={Vector} # tile 6 # text(1995.5,3469.5) color=magenta font="helvetica 14 bold roman" text={Region} # tile 7 # ruler(489.5,3707.5,361.5,3589.5) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 7 annulus(931.5,3643.5,20,40,60) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 7 ellipse(761.5,3651.5,30,15,60,30,45) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 7 box(587.5,3653.5,80,40,120,60,45) # font="helvetica 10 bold roman" text={Box Annulus} # tile 7 point(945.5,3829.5) # point=circle text={Circle Point} # tile 7 point(767.5,3833.5) # point=box color=red width=3 text={Box Point} # tile 7 point(605.5,3829.5) # point=diamond text={Diamond Point} # tile 7 point(915.5,3927.5) # point=cross color=blue text={Cross Point} # tile 7 point(763.5,3925.5) # point=x text={X Point} # tile 7 point(609.5,3931.5) # point=arrow color=magenta text={Arrow Point} # tile 7 point(759.5,4029.5) # point=boxcircle text={BoxCircle Point} # tile 7 # projection(281.5,3727.5,95.5,3595.5,40) text={Projection} # tile 7 panda(407.5,3829.5,0,270,3,0,60,2) # text={Panda} # tile 7 panda(403.5,4011.5,51.5819,90,1,0,30,1) # panda=(51.5819 90 180 270)(0 30 60) text={Panda 2} # tile 7 panda(403.5,4011.5,51.5819,90,1,30,60,1) # panda=ignore # tile 7 panda(403.5,4011.5,90,180,1,0,30,1) # panda=ignore # tile 7 panda(403.5,4011.5,90,180,1,30,60,1) # panda=ignore # tile 7 panda(403.5,4011.5,180,270,1,0,30,1) # panda=ignore # tile 7 panda(403.5,4011.5,180,270,1,30,60,1) # panda=ignore # tile 7 # compass(37.5,3685.5,80) compass=physical {N} {E} 1 1 text={Compass} # tile 7 epanda(243.5,3845.5,0,270,3,30,15,60,30,1,45) # text={Epanda} # tile 7 epanda(237.5,4023.5,45,90,1,30,15,60,30,1,45) # epanda=(45 90 180 270)(30 15 60 30)(45) text={Epanda 2} # tile 7 epanda(237.5,4023.5,90,180,1,30,15,60,30,1,45) # epanda=ignore # tile 7 epanda(237.5,4023.5,180,270,1,30,15,60,30,1,45) # epanda=ignore # tile 7 bpanda(69.5,3845.5,0,270,3,80,40,120,60,1,45) # text={Bpanda} # tile 7 bpanda(77.5,4021.5,45,90,1,80,40,120,60,1,45) # bpanda=(45 90 180 270)(80 40 120 60)(45) text={Bpanda 2} # tile 7 bpanda(77.5,4021.5,90,180,1,80,40,120,60,1,45) # bpanda=ignore # tile 7 bpanda(77.5,4021.5,180,270,1,80,40,120,60,1,45) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.linear.wcsc.reg0000644000076600000240000001372513336761120023332 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 wcsc; # tile 2 circle(121.5,3969.5,40) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 2 -ellipse(285.5,3935.5,80,40,45) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 2 -box(465.5,3931.5,160,80,45) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 2 polygon(603.9945,3953.5,679.5,4029.0055,755.0055,3953.5,679.5,3877.9945) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 2 -line(807.5,3903.5,927.5,4005.5) # line=1 1 color=cyan text={Line} # tile 2 # vector(995.5,3947.5,80,45) vector=1 color=red text={Vector} # tile 2 # text(1105.5,3919.5) color=magenta font="helvetica 14 bold roman" text={Region} # tile 2 # ruler(563.5,3681.5,691.5,3799.5) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 2 annulus(121.5,3745.5,20,40,60) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 2 ellipse(291.5,3737.5,30,15,60,30,45) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 2 box(465.5,3735.5,80,40,120,60,45) # font="helvetica 10 bold roman" text={Box Annulus} # tile 2 point(107.5,3559.5) # point=circle text={Circle Point} # tile 2 point(285.5,3555.5) # point=box color=red width=3 text={Box Point} # tile 2 point(447.5,3559.5) # point=diamond text={Diamond Point} # tile 2 point(137.5,3461.5) # point=cross color=blue text={Cross Point} # tile 2 point(289.5,3463.5) # point=x text={X Point} # tile 2 point(443.5,3457.5) # point=arrow color=magenta text={Arrow Point} # tile 2 point(293.5,3359.5) # point=boxcircle text={BoxCircle Point} # tile 2 # projection(771.5,3661.5,957.5,3793.5,40) text={Projection} # tile 2 panda(645.5,3559.5,0,270,3,0,60,2) # text={Panda} # tile 2 panda(649.5,3377.5,51.5819,90,1,0,30,1) # panda=(51.5819 90 180 270)(0 30 60) text={Panda 2} # tile 2 panda(649.5,3377.5,51.5819,90,1,30,60,1) # panda=ignore # tile 2 panda(649.5,3377.5,90,180,1,0,30,1) # panda=ignore # tile 2 panda(649.5,3377.5,90,180,1,30,60,1) # panda=ignore # tile 2 panda(649.5,3377.5,180,270,1,0,30,1) # panda=ignore # tile 2 panda(649.5,3377.5,180,270,1,30,60,1) # panda=ignore # tile 2 # compass(1015.5,3703.5,80) compass=physical {N} {E} 1 1 text={Compass} # tile 2 epanda(809.5,3543.5,0,270,3,30,15,60,30,1,45) # text={Epanda} # tile 2 epanda(815.5,3365.5,45,90,1,30,15,60,30,1,45) # epanda=(45 90 180 270)(30 15 60 30)(45) text={Epanda 2} # tile 2 epanda(815.5,3365.5,90,180,1,30,15,60,30,1,45) # epanda=ignore # tile 2 epanda(815.5,3365.5,180,270,1,30,15,60,30,1,45) # epanda=ignore # tile 2 bpanda(983.5,3543.5,0,270,3,80,40,120,60,1,45) # text={Bpanda} # tile 2 bpanda(975.5,3367.5,45,90,1,80,40,120,60,1,45) # bpanda=(45 90 180 270)(80 40 120 60)(45) text={Bpanda 2} # tile 2 bpanda(975.5,3367.5,90,180,1,80,40,120,60,1,45) # bpanda=ignore # tile 2 bpanda(975.5,3367.5,180,270,1,80,40,120,60,1,45) # bpanda=ignore # tile 7 circle(-929.5,3419.5,40) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 7 -ellipse(-765.5,3453.5,80,40,45) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 7 -box(-585.5,3457.5,160,80,45) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 7 polygon(-447.0055,3435.5,-371.5,3359.9945,-295.9945,3435.5,-371.5,3511.0055) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 7 -line(-243.5,3485.5,-123.5,3383.5) # line=1 1 color=cyan text={Line} # tile 7 # vector(-55.5,3441.5,80,45) vector=1 color=red text={Vector} # tile 6 # text(-1993.5,3469.5) color=magenta font="helvetica 14 bold roman" text={Region} # tile 7 # ruler(-487.5,3707.5,-359.5,3589.5) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 7 annulus(-929.5,3643.5,20,40,60) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 7 ellipse(-759.5,3651.5,30,15,60,30,45) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 7 box(-585.5,3653.5,80,40,120,60,45) # font="helvetica 10 bold roman" text={Box Annulus} # tile 7 point(-943.5,3829.5) # point=circle text={Circle Point} # tile 7 point(-765.5,3833.5) # point=box color=red width=3 text={Box Point} # tile 7 point(-603.5,3829.5) # point=diamond text={Diamond Point} # tile 7 point(-913.5,3927.5) # point=cross color=blue text={Cross Point} # tile 7 point(-761.5,3925.5) # point=x text={X Point} # tile 7 point(-607.5,3931.5) # point=arrow color=magenta text={Arrow Point} # tile 7 point(-757.5,4029.5) # point=boxcircle text={BoxCircle Point} # tile 7 # projection(-279.5,3727.5,-93.5,3595.5,40) text={Projection} # tile 7 panda(-405.5,3829.5,0,270,3,0,60,2) # text={Panda} # tile 7 panda(-401.5,4011.5,51.5819,90,1,0,30,1) # panda=(51.5819 90 180 270)(0 30 60) text={Panda 2} # tile 7 panda(-401.5,4011.5,51.5819,90,1,30,60,1) # panda=ignore # tile 7 panda(-401.5,4011.5,90,180,1,0,30,1) # panda=ignore # tile 7 panda(-401.5,4011.5,90,180,1,30,60,1) # panda=ignore # tile 7 panda(-401.5,4011.5,180,270,1,0,30,1) # panda=ignore # tile 7 panda(-401.5,4011.5,180,270,1,30,60,1) # panda=ignore # tile 7 # compass(-35.5,3685.5,80) compass=physical {N} {E} 1 1 text={Compass} # tile 7 epanda(-241.5,3845.5,0,270,3,30,15,60,30,1,45) # text={Epanda} # tile 7 epanda(-235.5,4023.5,45,90,1,30,15,60,30,1,45) # epanda=(45 90 180 270)(30 15 60 30)(45) text={Epanda 2} # tile 7 epanda(-235.5,4023.5,90,180,1,30,15,60,30,1,45) # epanda=ignore # tile 7 epanda(-235.5,4023.5,180,270,1,30,15,60,30,1,45) # epanda=ignore # tile 7 bpanda(-67.5,3845.5,0,270,3,80,40,120,60,1,45) # text={Bpanda} # tile 7 bpanda(-75.5,4021.5,45,90,1,80,40,120,60,1,45) # bpanda=(45 90 180 270)(80 40 120 60)(45) text={Bpanda 2} # tile 7 bpanda(-75.5,4021.5,90,180,1,80,40,120,60,1,45) # bpanda=ignore # tile 7 bpanda(-75.5,4021.5,180,270,1,80,40,120,60,1,45) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.linear.wcsd.reg0000644000076600000240000001404613336761120023330 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 wcsd; # tile 2 circle(3975.5,3969.5,40) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 2 -ellipse(3811.5,3935.5,80,40,135) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 2 -box(3631.5,3931.5,160,80,135) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 2 polygon(3493.0055,3953.5,3417.5,4029.0055,3341.9945,3953.5,3417.5,3877.9945) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 2 -line(3289.5,3903.5,3169.5,4005.5) # line=1 1 color=cyan text={Line} # tile 2 # vector(3101.5,3947.5,80,135) vector=1 color=red text={Vector} # tile 2 # text(2991.5,3919.5) color=magenta font="helvetica 14 bold roman" text={Region} # tile 2 # ruler(3533.5,3681.5,3405.5,3799.5) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 2 annulus(3975.5,3745.5,20,40,60) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 2 ellipse(3805.5,3737.5,30,15,60,30,135) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 2 box(3631.5,3735.5,80,40,120,60,135) # font="helvetica 10 bold roman" text={Box Annulus} # tile 2 point(3989.5,3559.5) # point=circle text={Circle Point} # tile 2 point(3811.5,3555.5) # point=box color=red width=3 text={Box Point} # tile 2 point(3649.5,3559.5) # point=diamond text={Diamond Point} # tile 2 point(3959.5,3461.5) # point=cross color=blue text={Cross Point} # tile 2 point(3807.5,3463.5) # point=x text={X Point} # tile 2 point(3653.5,3457.5) # point=arrow color=magenta text={Arrow Point} # tile 2 point(3803.5,3359.5) # point=boxcircle text={BoxCircle Point} # tile 2 # projection(3325.5,3661.5,3139.5,3793.5,40) text={Projection} # tile 2 panda(3451.5,3559.5,180,270,3,0,60,2) # text={Panda} # tile 2 panda(3447.5,3377.5,128.4181,450,1,0,30,1) # panda=(128.4181 90 0 270)(0 30 60) text={Panda 2} # tile 2 panda(3447.5,3377.5,128.4181,450,1,30,60,1) # panda=ignore # tile 2 panda(3447.5,3377.5,90,360,1,0,30,1) # panda=ignore # tile 2 panda(3447.5,3377.5,90,360,1,30,60,1) # panda=ignore # tile 2 panda(3447.5,3377.5,0,270,1,0,30,1) # panda=ignore # tile 2 panda(3447.5,3377.5,0,270,1,30,60,1) # panda=ignore # tile 2 # compass(3081.5,3703.5,80) compass=physical {N} {E} 1 1 text={Compass} # tile 2 epanda(3287.5,3543.5,180,270,3,30,15,60,30,1,135) # text={Epanda} # tile 2 epanda(3281.5,3365.5,135,450,1,30,15,60,30,1,135) # epanda=(135 90 0 270)(30 15 60 30)(135) text={Epanda 2} # tile 2 epanda(3281.5,3365.5,90,360,1,30,15,60,30,1,135) # epanda=ignore # tile 2 epanda(3281.5,3365.5,0,270,1,30,15,60,30,1,135) # epanda=ignore # tile 2 bpanda(3113.5,3543.5,180,270,3,80,40,120,60,1,135) # text={Bpanda} # tile 2 bpanda(3121.5,3367.5,135,450,1,80,40,120,60,1,135) # bpanda=(135 90 0 270)(80 40 120 60)(135) text={Bpanda 2} # tile 2 bpanda(3121.5,3367.5,90,360,1,80,40,120,60,1,135) # bpanda=ignore # tile 2 bpanda(3121.5,3367.5,0,270,1,80,40,120,60,1,135) # bpanda=ignore # tile 7 circle(5027.5,4773.5,40) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 7 -ellipse(4863.5,4739.5,80,40,135) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 7 -box(4683.5,4735.5,160,80,135) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 7 polygon(4545.0055,4757.5,4469.5,4833.0055,4393.9945,4757.5,4469.5,4681.9945) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 7 -line(4341.5,4707.5,4221.5,4809.5) # line=1 1 color=cyan text={Line} # tile 7 # vector(4153.5,4751.5,80,135) vector=1 color=red text={Vector} # tile 6 # text(4043.5,4723.5) color=magenta font="helvetica 14 bold roman" text={Region} # tile 7 # ruler(4585.5,4485.5,4457.5,4603.5) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 7 annulus(5027.5,4549.5,20,40,60) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 7 ellipse(4857.5,4541.5,30,15,60,30,135) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 7 box(4683.5,4539.5,80,40,120,60,135) # font="helvetica 10 bold roman" text={Box Annulus} # tile 7 point(5041.5,4363.5) # point=circle text={Circle Point} # tile 7 point(4863.5,4359.5) # point=box color=red width=3 text={Box Point} # tile 7 point(4701.5,4363.5) # point=diamond text={Diamond Point} # tile 7 point(5011.5,4265.5) # point=cross color=blue text={Cross Point} # tile 7 point(4859.5,4267.5) # point=x text={X Point} # tile 7 point(4705.5,4261.5) # point=arrow color=magenta text={Arrow Point} # tile 7 point(4855.5,4163.5) # point=boxcircle text={BoxCircle Point} # tile 7 # projection(4377.5,4465.5,4191.5,4597.5,40) text={Projection} # tile 7 panda(4503.5,4363.5,180,270,3,0,60,2) # text={Panda} # tile 7 panda(4499.5,4181.5,128.4181,450,1,0,30,1) # panda=(128.4181 90 0 270)(0 30 60) text={Panda 2} # tile 7 panda(4499.5,4181.5,128.4181,450,1,30,60,1) # panda=ignore # tile 7 panda(4499.5,4181.5,90,360,1,0,30,1) # panda=ignore # tile 7 panda(4499.5,4181.5,90,360,1,30,60,1) # panda=ignore # tile 7 panda(4499.5,4181.5,0,270,1,0,30,1) # panda=ignore # tile 7 panda(4499.5,4181.5,0,270,1,30,60,1) # panda=ignore # tile 7 # compass(4133.5,4507.5,80) compass=physical {N} {E} 1 1 text={Compass} # tile 7 epanda(4339.5,4347.5,180,270,3,30,15,60,30,1,135) # text={Epanda} # tile 7 epanda(4333.5,4169.5,135,450,1,30,15,60,30,1,135) # epanda=(135 90 0 270)(30 15 60 30)(135) text={Epanda 2} # tile 7 epanda(4333.5,4169.5,90,360,1,30,15,60,30,1,135) # epanda=ignore # tile 7 epanda(4333.5,4169.5,0,270,1,30,15,60,30,1,135) # epanda=ignore # tile 7 bpanda(4165.5,4347.5,180,270,3,80,40,120,60,1,135) # text={Bpanda} # tile 7 bpanda(4173.5,4171.5,135,450,1,80,40,120,60,1,135) # bpanda=(135 90 0 270)(80 40 120 60)(135) text={Bpanda 2} # tile 7 bpanda(4173.5,4171.5,90,360,1,80,40,120,60,1,135) # bpanda=ignore # tile 7 bpanda(4173.5,4171.5,0,270,1,80,40,120,60,1,135) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.linear.wcsi.reg0000644000076600000240000001311013336761120023324 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 wcsi; # tile 2 circle(67,1135,20) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 2 -ellipse(149,1118,40,20,45) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 2 -box(239,1116,80,40,45) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 2 polygon(308.24725,1127,346,1164.7528,383.75275,1127,346,1089.2472) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 2 -line(410,1102,470,1153) # line=1 1 color=cyan text={Line} # tile 2 # vector(504,1124,40,45) vector=1 color=red text={Vector} # tile 2 # text(559,1110) color=magenta font="helvetica 14 bold roman" text={Region} # tile 2 # ruler(288,991,352,1050) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 2 annulus(67,1023,10,20,30) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 2 ellipse(152,1019,15,7.5,30,15,45) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 2 box(239,1018,40,20,60,30,45) # font="helvetica 10 bold roman" text={Box Annulus} # tile 2 point(60,930) # point=circle text={Circle Point} # tile 2 point(149,928) # point=box color=red width=3 text={Box Point} # tile 2 point(230,930) # point=diamond text={Diamond Point} # tile 2 point(75,881) # point=cross color=blue text={Cross Point} # tile 2 point(151,882) # point=x text={X Point} # tile 2 point(228,879) # point=arrow color=magenta text={Arrow Point} # tile 2 point(153,830) # point=boxcircle text={BoxCircle Point} # tile 2 # projection(392,981,485,1047,20) text={Projection} # tile 2 panda(329,930,0,270,3,0,30,2) # text={Panda} # tile 2 panda(331,839,51.5819,90,1,0,15,1) # panda=(51.5819 90 180 270)(0 15 30) text={Panda 2} # tile 2 panda(331,839,51.5819,90,1,15,30,1) # panda=ignore # tile 2 panda(331,839,90,180,1,0,15,1) # panda=ignore # tile 2 panda(331,839,90,180,1,15,30,1) # panda=ignore # tile 2 panda(331,839,180,270,1,0,15,1) # panda=ignore # tile 2 panda(331,839,180,270,1,15,30,1) # panda=ignore # tile 2 # compass(514,1002,40) compass=physical {N} {E} 1 1 text={Compass} # tile 2 epanda(411,922,0,270,3,15,7.5,30,15,1,45) # text={Epanda} # tile 2 epanda(414,833,45,90,1,15,7.5,30,15,1,45) # epanda=(45 90 180 270)(15 7.5 30 15)(45) text={Epanda 2} # tile 2 epanda(414,833,90,180,1,15,7.5,30,15,1,45) # epanda=ignore # tile 2 epanda(414,833,180,270,1,15,7.5,30,15,1,45) # epanda=ignore # tile 2 bpanda(498,922,0,270,3,40,20,60,30,1,45) # text={Bpanda} # tile 2 bpanda(494,834,45,90,1,40,20,60,30,1,45) # bpanda=(45 90 180 270)(40 20 60 30)(45) text={Bpanda 2} # tile 2 bpanda(494,834,90,180,1,40,20,60,30,1,45) # bpanda=ignore # tile 2 bpanda(494,834,180,270,1,40,20,60,30,1,45) # bpanda=ignore # tile 7 circle(472,860,20) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 7 -ellipse(390,877,40,20,45) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 7 -box(300,879,80,40,45) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 7 polygon(230.75275,868,193,830.24725,155.24725,868,193,905.75275) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 7 -line(129,893,69,842) # line=1 1 color=cyan text={Line} # tile 7 # vector(35,871,40,45) vector=1 color=red text={Vector} # tile 6 # text(1004,885) color=magenta font="helvetica 14 bold roman" text={Region} # tile 7 # ruler(251,1004,187,945) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 7 annulus(472,972,10,20,30) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 7 ellipse(387,976,15,7.5,30,15,45) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 7 box(300,977,40,20,60,30,45) # font="helvetica 10 bold roman" text={Box Annulus} # tile 7 point(479,1065) # point=circle text={Circle Point} # tile 7 point(390,1067) # point=box color=red width=3 text={Box Point} # tile 7 point(309,1065) # point=diamond text={Diamond Point} # tile 7 point(464,1114) # point=cross color=blue text={Cross Point} # tile 7 point(388,1113) # point=x text={X Point} # tile 7 point(311,1116) # point=arrow color=magenta text={Arrow Point} # tile 7 point(386,1165) # point=boxcircle text={BoxCircle Point} # tile 7 # projection(147,1014,54,948,20) text={Projection} # tile 7 panda(210,1065,0,270,3,0,30,2) # text={Panda} # tile 7 panda(208,1156,51.5819,90,1,0,15,1) # panda=(51.5819 90 180 270)(0 15 30) text={Panda 2} # tile 7 panda(208,1156,51.5819,90,1,15,30,1) # panda=ignore # tile 7 panda(208,1156,90,180,1,0,15,1) # panda=ignore # tile 7 panda(208,1156,90,180,1,15,30,1) # panda=ignore # tile 7 panda(208,1156,180,270,1,0,15,1) # panda=ignore # tile 7 panda(208,1156,180,270,1,15,30,1) # panda=ignore # tile 7 # compass(25,993,40) compass=physical {N} {E} 1 1 text={Compass} # tile 7 epanda(128,1073,0,270,3,15,7.5,30,15,1,45) # text={Epanda} # tile 7 epanda(125,1162,45,90,1,15,7.5,30,15,1,45) # epanda=(45 90 180 270)(15 7.5 30 15)(45) text={Epanda 2} # tile 7 epanda(125,1162,90,180,1,15,7.5,30,15,1,45) # epanda=ignore # tile 7 epanda(125,1162,180,270,1,15,7.5,30,15,1,45) # epanda=ignore # tile 7 bpanda(41,1073,0,270,3,40,20,60,30,1,45) # text={Bpanda} # tile 7 bpanda(45,1161,45,90,1,40,20,60,30,1,45) # bpanda=(45 90 180 270)(40 20 60 30)(45) text={Bpanda 2} # tile 7 bpanda(45,1161,90,180,1,40,20,60,30,1,45) # bpanda=ignore # tile 7 bpanda(45,1161,180,270,1,40,20,60,30,1,45) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.linear.wcsp.reg0000644000076600000240000001335613336761120023347 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 wcsp; # tile 2 circle(3975,3969,40) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 2 -ellipse(3811,3935,80,40,135) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 2 -box(3631,3931,160,80,135) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 2 polygon(3492.5055,3953,3417,4028.5055,3341.4945,3953,3417,3877.4945) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 2 -line(3289,3903,3169,4005) # line=1 1 color=cyan text={Line} # tile 2 # vector(3101,3947,80,135) vector=1 color=red text={Vector} # tile 2 # text(2991,3919) color=magenta font="helvetica 14 bold roman" text={Region} # tile 2 # ruler(3533,3681,3405,3799) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 2 annulus(3975,3745,20,40,60) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 2 ellipse(3805,3737,30,15,60,30,135) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 2 box(3631,3735,80,40,120,60,135) # font="helvetica 10 bold roman" text={Box Annulus} # tile 2 point(3989,3559) # point=circle text={Circle Point} # tile 2 point(3811,3555) # point=box color=red width=3 text={Box Point} # tile 2 point(3649,3559) # point=diamond text={Diamond Point} # tile 2 point(3959,3461) # point=cross color=blue text={Cross Point} # tile 2 point(3807,3463) # point=x text={X Point} # tile 2 point(3653,3457) # point=arrow color=magenta text={Arrow Point} # tile 2 point(3803,3359) # point=boxcircle text={BoxCircle Point} # tile 2 # projection(3325,3661,3139,3793,40) text={Projection} # tile 2 panda(3451,3559,180,270,3,0,60,2) # text={Panda} # tile 2 panda(3447,3377,128.4181,450,1,0,30,1) # panda=(128.4181 90 0 270)(0 30 60) text={Panda 2} # tile 2 panda(3447,3377,128.4181,450,1,30,60,1) # panda=ignore # tile 2 panda(3447,3377,90,360,1,0,30,1) # panda=ignore # tile 2 panda(3447,3377,90,360,1,30,60,1) # panda=ignore # tile 2 panda(3447,3377,0,270,1,0,30,1) # panda=ignore # tile 2 panda(3447,3377,0,270,1,30,60,1) # panda=ignore # tile 2 # compass(3081,3703,80) compass=physical {N} {E} 1 1 text={Compass} # tile 2 epanda(3287,3543,180,270,3,30,15,60,30,1,135) # text={Epanda} # tile 2 epanda(3281,3365,135,450,1,30,15,60,30,1,135) # epanda=(135 90 0 270)(30 15 60 30)(135) text={Epanda 2} # tile 2 epanda(3281,3365,90,360,1,30,15,60,30,1,135) # epanda=ignore # tile 2 epanda(3281,3365,0,270,1,30,15,60,30,1,135) # epanda=ignore # tile 2 bpanda(3113,3543,180,270,3,80,40,120,60,1,135) # text={Bpanda} # tile 2 bpanda(3121,3367,135,450,1,80,40,120,60,1,135) # bpanda=(135 90 0 270)(80 40 120 60)(135) text={Bpanda 2} # tile 2 bpanda(3121,3367,90,360,1,80,40,120,60,1,135) # bpanda=ignore # tile 2 bpanda(3121,3367,0,270,1,80,40,120,60,1,135) # bpanda=ignore # tile 7 circle(5027,4773,40) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 7 -ellipse(4863,4739,80,40,135) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 7 -box(4683,4735,160,80,135) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 7 polygon(4544.5055,4757,4469,4832.5055,4393.4945,4757,4469,4681.4945) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 7 -line(4341,4707,4221,4809) # line=1 1 color=cyan text={Line} # tile 7 # vector(4153,4751,80,135) vector=1 color=red text={Vector} # tile 6 # text(4043,4723) color=magenta font="helvetica 14 bold roman" text={Region} # tile 7 # ruler(4585,4485,4457,4603) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 7 annulus(5027,4549,20,40,60) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 7 ellipse(4857,4541,30,15,60,30,135) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 7 box(4683,4539,80,40,120,60,135) # font="helvetica 10 bold roman" text={Box Annulus} # tile 7 point(5041,4363) # point=circle text={Circle Point} # tile 7 point(4863,4359) # point=box color=red width=3 text={Box Point} # tile 7 point(4701,4363) # point=diamond text={Diamond Point} # tile 7 point(5011,4265) # point=cross color=blue text={Cross Point} # tile 7 point(4859,4267) # point=x text={X Point} # tile 7 point(4705,4261) # point=arrow color=magenta text={Arrow Point} # tile 7 point(4855,4163) # point=boxcircle text={BoxCircle Point} # tile 7 # projection(4377,4465,4191,4597,40) text={Projection} # tile 7 panda(4503,4363,180,270,3,0,60,2) # text={Panda} # tile 7 panda(4499,4181,128.4181,450,1,0,30,1) # panda=(128.4181 90 0 270)(0 30 60) text={Panda 2} # tile 7 panda(4499,4181,128.4181,450,1,30,60,1) # panda=ignore # tile 7 panda(4499,4181,90,360,1,0,30,1) # panda=ignore # tile 7 panda(4499,4181,90,360,1,30,60,1) # panda=ignore # tile 7 panda(4499,4181,0,270,1,0,30,1) # panda=ignore # tile 7 panda(4499,4181,0,270,1,30,60,1) # panda=ignore # tile 7 # compass(4133,4507,80) compass=physical {N} {E} 1 1 text={Compass} # tile 7 epanda(4339,4347,180,270,3,30,15,60,30,1,135) # text={Epanda} # tile 7 epanda(4333,4169,135,450,1,30,15,60,30,1,135) # epanda=(135 90 0 270)(30 15 60 30)(135) text={Epanda 2} # tile 7 epanda(4333,4169,90,360,1,30,15,60,30,1,135) # epanda=ignore # tile 7 epanda(4333,4169,0,270,1,30,15,60,30,1,135) # epanda=ignore # tile 7 bpanda(4165,4347,180,270,3,80,40,120,60,1,135) # text={Bpanda} # tile 7 bpanda(4173,4171,135,450,1,80,40,120,60,1,135) # bpanda=(135 90 0 270)(80 40 120 60)(135) text={Bpanda 2} # tile 7 bpanda(4173,4171,90,360,1,80,40,120,60,1,135) # bpanda=ignore # tile 7 bpanda(4173,4171,0,270,1,80,40,120,60,1,135) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.mosaic.ecliptic.hms.reg0000644000076600000240000001707513336761120024760 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 ecliptic circle(+275:41:56.645,+54:45:59.579,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(+275:41:08.911,+54:45:55.184,13.32",6.66",47.5211) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(+275:40:16.965,+54:45:55.895,26.64",13.32",47.5211) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(+275:39:37.328,+54:46:00.610,+275:39:16.553,+54:46:13.742,+275:38:53.790,+54:46:01.756,+275:39:14.565,+54:45:48.625) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(+275:38:37.999,+54:45:53.837,+275:38:04.737,+54:46:11.709) # line=1 1 color=cyan text={Line} # vector(+275:37:44.373,+54:46:02.575,13.32",47.5211) vector=1 color=red text={Vector} # text(+275:37:12.294,+54:45:58.745) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(+275:39:45.414,+54:45:15.061,+275:39:10.074,+54:45:35.660) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(+275:41:53.657,+54:45:22.323,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(+275:41:04.552,+54:45:22.298,4.995",2.4975",9.99",4.995",47.5211) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(+275:40:14.373,+54:45:23.296,13.32",6.66",19.98",9.99",47.5211) # font="helvetica 10 bold roman" text={Box Annulus} point(+275:41:55.211,+54:44:51.279) # point=circle text={Circle Point} point(+275:41:03.864,+54:44:51.981) # point=box color=red width=3 text={Box Point} point(+275:40:17.234,+54:44:53.885) # point=diamond text={Diamond Point} point(+275:41:45.260,+54:44:35.210) # point=cross color=blue text={Cross Point} point(+275:41:01.490,+54:44:36.710) # point=x text={X Point} point(+275:40:17.038,+54:44:36.889) # point=arrow color=magenta text={Arrow Point} point(+275:40:58.958,+54:44:19.443) # point=boxcircle text={BoxCircle Point} # projection(+275:38:45.202,+54:45:13.313,+275:37:53.317,+54:45:36.674,6.66") text={Projection} panda(+275:39:20.175,+54:44:55.392,2.52109,272.521,3,0",9.99",2) # text={Panda} panda(+275:39:16.628,+54:44:25.151,54.103,92.5211,1,0",4.995",1) # panda=(54.103 92.5211 182.521 272.521)(0" 4.995" 9.99") text={Panda 2} panda(+275:39:16.628,+54:44:25.151,54.103,92.5211,1,4.995",9.99",1) # panda=ignore panda(+275:39:16.628,+54:44:25.151,92.5211,182.521,1,0",4.995",1) # panda=ignore panda(+275:39:16.628,+54:44:25.151,92.5211,182.521,1,4.995",9.99",1) # panda=ignore panda(+275:39:16.628,+54:44:25.151,182.521,272.521,1,0",4.995",1) # panda=ignore panda(+275:39:16.628,+54:44:25.151,182.521,272.521,1,4.995",9.99",1) # panda=ignore # compass(+275:37:35.424,+54:45:22.141,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(+275:38:32.703,+54:44:53.974,2.52109,272.521,3,4.995",2.4975",9.99",4.995",1,47.5211) # text={Epanda} epanda(+275:38:28.642,+54:44:24.413,47.5211,92.5211,1,4.995",2.4975",9.99",4.995",1,47.5211) # epanda=(47.5211 92.5211 182.521 272.521)(4.995" 2.4975" 9.99" 4.995")(47.5211) text={Epanda 2} epanda(+275:38:28.642,+54:44:24.413,92.5211,182.521,1,4.995",2.4975",9.99",4.995",1,47.5211) # epanda=ignore epanda(+275:38:28.642,+54:44:24.413,182.521,272.521,1,4.995",2.4975",9.99",4.995",1,47.5211) # epanda=ignore bpanda(+275:37:42.560,+54:44:55.287,2.52109,272.521,3,13.32",6.66",19.98",9.99",1,47.5211) # text={Bpanda} bpanda(+275:37:42.569,+54:44:25.953,47.5211,92.5211,1,13.32",6.66",19.98",9.99",1,47.5211) # bpanda=(47.5211 92.5211 182.521 272.521)(13.32" 6.66" 19.98" 9.99")(47.5211) text={Bpanda 2} bpanda(+275:37:42.569,+54:44:25.953,92.5211,182.521,1,13.32",6.66",19.98",9.99",1,47.5211) # bpanda=ignore bpanda(+275:37:42.569,+54:44:25.953,182.521,272.521,1,13.32",6.66",19.98",9.99",1,47.5211) # bpanda=ignore circle(+275:49:30.767,+54:48:31.242,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(+275:48:42.970,+54:48:26.897,13.32",6.66",47.5211) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(+275:47:50.972,+54:48:27.662,26.64",13.32",47.5211) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(+275:47:11.308,+54:48:32.418,+275:46:50.552,+54:48:45.571,+275:46:27.728,+54:48:33.609,+275:46:48.485,+54:48:20.456) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(+275:46:11.897,+54:48:25.707,+275:45:38.656,+54:48:43.613) # line=1 1 color=cyan text={Line} # vector(+275:45:18.242,+54:48:34.500,13.32",47.5211) vector=1 color=red text={Vector} # text(+275:44:46.117,+54:48:30.703) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(+275:47:19.261,+54:47:46.861,+275:46:43.948,+54:48:07.496) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(+275:49:27.659,+54:47:53.989,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(+275:48:38.503,+54:47:54.015,4.995",2.4975",9.99",4.995",47.5211) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(+275:47:48.276,+54:47:55.065,13.32",6.66",19.98",9.99",47.5211) # font="helvetica 10 bold roman" text={Box Annulus} point(+275:49:29.118,+54:47:22.944) # point=circle text={Circle Point} point(+275:48:37.721,+54:47:23.699) # point=box color=red width=3 text={Box Point} point(+275:47:51.047,+54:47:25.652) # point=diamond text={Diamond Point} point(+275:49:19.107,+54:47:06.886) # point=cross color=blue text={Cross Point} point(+275:48:35.297,+54:47:08.431) # point=x text={X Point} point(+275:47:50.798,+54:47:08.656) # point=arrow color=magenta text={Arrow Point} point(+275:48:32.708,+54:46:51.166) # point=boxcircle text={BoxCircle Point} # projection(+275:46:18.980,+54:47:45.175,+275:45:27.114,+54:48:08.590,6.66") text={Projection} panda(+275:46:53.934,+54:47:27.218,2.52109,272.521,3,0",9.99",2) # text={Panda} panda(+275:46:50.289,+54:46:56.981,54.103,92.5211,1,0",4.995",1) # panda=(54.103 92.5211 182.521 272.521)(0" 4.995" 9.99") text={Panda 2} panda(+275:46:50.289,+54:46:56.981,54.103,92.5211,1,4.995",9.99",1) # panda=ignore panda(+275:46:50.289,+54:46:56.981,92.5211,182.521,1,0",4.995",1) # panda=ignore panda(+275:46:50.289,+54:46:56.981,92.5211,182.521,1,4.995",9.99",1) # panda=ignore panda(+275:46:50.289,+54:46:56.981,182.521,272.521,1,0",4.995",1) # panda=ignore panda(+275:46:50.289,+54:46:56.981,182.521,272.521,1,4.995",9.99",1) # panda=ignore # compass(+275:45:09.157,+54:47:54.075,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(+275:46:06.408,+54:47:25.849,2.52109,272.521,3,4.995",2.4975",9.99",4.995",1,47.5211) # text={Epanda} epanda(+275:46:02.251,+54:46:56.293,47.5211,92.5211,1,4.995",2.4975",9.99",4.995",1,47.5211) # epanda=(47.5211 92.5211 182.521 272.521)(4.995" 2.4975" 9.99" 4.995")(47.5211) text={Epanda 2} epanda(+275:46:02.251,+54:46:56.293,92.5211,182.521,1,4.995",2.4975",9.99",4.995",1,47.5211) # epanda=ignore epanda(+275:46:02.251,+54:46:56.293,182.521,272.521,1,4.995",2.4975",9.99",4.995",1,47.5211) # epanda=ignore bpanda(+275:45:16.217,+54:47:27.214,2.52109,272.521,3,13.32",6.66",19.98",9.99",1,47.5211) # text={Bpanda} bpanda(+275:45:16.134,+54:46:57.880,47.5211,92.5211,1,13.32",6.66",19.98",9.99",1,47.5211) # bpanda=(47.5211 92.5211 182.521 272.521)(13.32" 6.66" 19.98" 9.99")(47.5211) text={Bpanda 2} bpanda(+275:45:16.134,+54:46:57.880,92.5211,182.521,1,13.32",6.66",19.98",9.99",1,47.5211) # bpanda=ignore bpanda(+275:45:16.134,+54:46:57.880,182.521,272.521,1,13.32",6.66",19.98",9.99",1,47.5211) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.mosaic.ecliptic.reg0000644000076600000240000001606013336761120024163 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 ecliptic circle(275.69907,54.76655,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(275.68581,54.765329,13.32",6.66",47.521086) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(275.67138,54.765526,26.64",13.32",47.521086) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(275.66037,54.766836,275.6546,54.770484,275.64827,54.767154,275.65405,54.763507) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(275.64389,54.764955,275.63465,54.769919) # line=1 1 color=cyan text={Line} # vector(275.62899,54.767382,13.32",47.521086) vector=1 color=red text={Vector} # text(275.62008,54.766318) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(275.66262,54.754184,275.6528,54.759906) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(275.69824,54.756201,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(275.6846,54.756194,4.995",2.4975",9.99",4.995",47.521086) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(275.67066,54.756471,13.32",6.66",19.98",9.99",47.521086) # font="helvetica 10 bold roman" text={Box Annulus} point(275.69867,54.747578) # point=circle text={Circle Point} point(275.68441,54.747772) # point=box color=red width=3 text={Box Point} point(275.67145,54.748301) # point=diamond text={Diamond Point} point(275.69591,54.743114) # point=cross color=blue text={Cross Point} point(275.68375,54.74353) # point=x text={X Point} point(275.6714,54.74358) # point=arrow color=magenta text={Arrow Point} point(275.68304,54.738734) # point=boxcircle text={BoxCircle Point} # projection(275.64589,54.753698,275.63148,54.760187,6.66") text={Projection} panda(275.6556,54.74872,2.5210862,272.52109,3,0",9.99",2) # text={Panda} panda(275.65462,54.74032,54.102986,92.521086,1,0",4.995",1) # panda=(54.102986 92.521086 182.52109 272.52109)(0" 4.995" 9.99") text={Panda 2} panda(275.65462,54.74032,54.102986,92.521086,1,4.995",9.99",1) # panda=ignore panda(275.65462,54.74032,92.521086,182.52109,1,0",4.995",1) # panda=ignore panda(275.65462,54.74032,92.521086,182.52109,1,4.995",9.99",1) # panda=ignore panda(275.65462,54.74032,182.52109,272.52109,1,0",4.995",1) # panda=ignore panda(275.65462,54.74032,182.52109,272.52109,1,4.995",9.99",1) # panda=ignore # compass(275.62651,54.75615,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(275.64242,54.748326,2.5210862,272.52109,3,4.995",2.4975",9.99",4.995",1,47.521086) # text={Epanda} epanda(275.64129,54.740115,47.521086,92.521086,1,4.995",2.4975",9.99",4.995",1,47.521086) # epanda=(47.521086 92.521086 182.52109 272.52109)(4.995" 2.4975" 9.99" 4.995")(47.521086) text={Epanda 2} epanda(275.64129,54.740115,92.521086,182.52109,1,4.995",2.4975",9.99",4.995",1,47.521086) # epanda=ignore epanda(275.64129,54.740115,182.52109,272.52109,1,4.995",2.4975",9.99",4.995",1,47.521086) # epanda=ignore bpanda(275.62849,54.748691,2.5210862,272.52109,3,13.32",6.66",19.98",9.99",1,47.521086) # text={Bpanda} bpanda(275.62849,54.740543,47.521086,92.521086,1,13.32",6.66",19.98",9.99",1,47.521086) # bpanda=(47.521086 92.521086 182.52109 272.52109)(13.32" 6.66" 19.98" 9.99")(47.521086) text={Bpanda 2} bpanda(275.62849,54.740543,92.521086,182.52109,1,13.32",6.66",19.98",9.99",1,47.521086) # bpanda=ignore bpanda(275.62849,54.740543,182.52109,272.52109,1,13.32",6.66",19.98",9.99",1,47.521086) # bpanda=ignore circle(275.82521,54.808678,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(275.81194,54.807471,13.32",6.66",47.521086) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(275.79749,54.807684,26.64",13.32",47.521086) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(275.78647,54.809005,275.78071,54.812659,275.77437,54.809336,275.78013,54.805682) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(275.76997,54.807141,275.76074,54.812115) # line=1 1 color=cyan text={Line} # vector(275.75507,54.809583,13.32",47.521086) vector=1 color=red text={Vector} # text(275.74614,54.808529) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(275.78868,54.79635,275.77887,54.802082) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(275.82435,54.79833,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(275.8107,54.798338,4.995",2.4975",9.99",4.995",47.521086) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(275.79674,54.798629,13.32",6.66",19.98",9.99",47.521086) # font="helvetica 10 bold roman" text={Box Annulus} point(275.82476,54.789707) # point=circle text={Circle Point} point(275.81048,54.789916) # point=box color=red width=3 text={Box Point} point(275.79751,54.790459) # point=diamond text={Diamond Point} point(275.82197,54.785246) # point=cross color=blue text={Cross Point} point(275.8098,54.785675) # point=x text={X Point} point(275.79744,54.785738) # point=arrow color=magenta text={Arrow Point} point(275.80909,54.780879) # point=boxcircle text={BoxCircle Point} # projection(275.77194,54.795882,275.75753,54.802386,6.66") text={Projection} panda(275.78165,54.790894,2.5210862,272.52109,3,0",9.99",2) # text={Panda} panda(275.78064,54.782495,54.102986,92.521086,1,0",4.995",1) # panda=(54.102986 92.521086 182.52109 272.52109)(0" 4.995" 9.99") text={Panda 2} panda(275.78064,54.782495,54.102986,92.521086,1,4.995",9.99",1) # panda=ignore panda(275.78064,54.782495,92.521086,182.52109,1,0",4.995",1) # panda=ignore panda(275.78064,54.782495,92.521086,182.52109,1,4.995",9.99",1) # panda=ignore panda(275.78064,54.782495,182.52109,272.52109,1,0",4.995",1) # panda=ignore panda(275.78064,54.782495,182.52109,272.52109,1,4.995",9.99",1) # panda=ignore # compass(275.75254,54.798354,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(275.76845,54.790514,2.5210862,272.52109,3,4.995",2.4975",9.99",4.995",1,47.521086) # text={Epanda} epanda(275.76729,54.782303,47.521086,92.521086,1,4.995",2.4975",9.99",4.995",1,47.521086) # epanda=(47.521086 92.521086 182.52109 272.52109)(4.995" 2.4975" 9.99" 4.995")(47.521086) text={Epanda 2} epanda(275.76729,54.782303,92.521086,182.52109,1,4.995",2.4975",9.99",4.995",1,47.521086) # epanda=ignore epanda(275.76729,54.782303,182.52109,272.52109,1,4.995",2.4975",9.99",4.995",1,47.521086) # epanda=ignore bpanda(275.7545,54.790893,2.5210862,272.52109,3,13.32",6.66",19.98",9.99",1,47.521086) # text={Bpanda} bpanda(275.75448,54.782745,47.521086,92.521086,1,13.32",6.66",19.98",9.99",1,47.521086) # bpanda=(47.521086 92.521086 182.52109 272.52109)(13.32" 6.66" 19.98" 9.99")(47.521086) text={Bpanda 2} bpanda(275.75448,54.782745,92.521086,182.52109,1,13.32",6.66",19.98",9.99",1,47.521086) # bpanda=ignore bpanda(275.75448,54.782745,182.52109,272.52109,1,13.32",6.66",19.98",9.99",1,47.521086) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.mosaic.fk4.hms.reg0000644000076600000240000001651613336761120023647 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 fk4 circle(18:13:32.047,+31:23:09.41,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(18:13:29.912,+31:23:03.90,13.32",6.66",45.2623) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(18:13:27.572,+31:23:03.40,26.64",13.32",45.2623) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(18:13:25.772,+31:23:07.18,18:13:24.796,+31:23:19.82,18:13:23.809,+31:23:07.32,18:13:24.786,+31:22:54.68) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(18:13:23.123,+31:22:59.04,18:13:21.570,+31:23:16.12) # line=1 1 color=cyan text={Line} # vector(18:13:20.682,+31:23:06.52,13.32",45.2623) vector=1 color=red text={Vector} # text(18:13:19.250,+31:23:01.96) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(18:13:26.280,+31:22:21.86,18:13:24.624,+31:22:41.62) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(18:13:32.031,+31:22:32.11,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(18:13:29.820,+31:22:30.94,4.995",2.4975",9.99",4.995",45.2623) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(18:13:27.558,+31:22:30.76,13.32",6.66",19.98",9.99",45.2623) # font="helvetica 10 bold roman" text={Box Annulus} point(18:13:32.200,+31:22:01.13) # point=circle text={Circle Point} point(18:13:29.885,+31:22:00.63) # point=box color=red width=3 text={Box Point} point(18:13:27.780,+31:22:01.44) # point=diamond text={Diamond Point} point(18:13:31.802,+31:21:44.84) # point=cross color=blue text={Cross Point} point(18:13:29.827,+31:21:45.32) # point=x text={X Point} point(18:13:27.824,+31:21:44.46) # point=arrow color=magenta text={Arrow Point} point(18:13:29.767,+31:21:28.00) # point=boxcircle text={BoxCircle Point} # projection(18:13:23.575,+31:22:18.71,18:13:21.165,+31:22:40.85,6.66") text={Projection} panda(18:13:25.206,+31:22:01.62,0.262262,270.262,3,0",9.99",2) # text={Panda} panda(18:13:25.141,+31:21:31.32,51.8442,90.2623,1,0",4.995",1) # panda=(51.8442 90.2623 180.262 270.262)(0" 4.995" 9.99") text={Panda 2} panda(18:13:25.141,+31:21:31.32,51.8442,90.2623,1,4.995",9.99",1) # panda=ignore panda(18:13:25.141,+31:21:31.32,90.2623,180.262,1,0",4.995",1) # panda=ignore panda(18:13:25.141,+31:21:31.32,90.2623,180.262,1,4.995",9.99",1) # panda=ignore panda(18:13:25.141,+31:21:31.32,180.262,270.262,1,0",4.995",1) # panda=ignore panda(18:13:25.141,+31:21:31.32,180.262,270.262,1,4.995",9.99",1) # panda=ignore # compass(18:13:20.405,+31:22:25.92,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(18:13:23.073,+31:21:59.10,0.262262,270.262,3,4.995",2.4975",9.99",4.995",1,45.2623) # text={Epanda} epanda(18:13:22.983,+31:21:29.47,45.2623,90.2623,1,4.995",2.4975",9.99",4.995",1,45.2623) # epanda=(45.2623 90.2623 180.262 270.262)(4.995" 2.4975" 9.99" 4.995")(45.2623) text={Epanda 2} epanda(18:13:22.983,+31:21:29.47,90.2623,180.262,1,4.995",2.4975",9.99",4.995",1,45.2623) # epanda=ignore epanda(18:13:22.983,+31:21:29.47,180.262,270.262,1,4.995",2.4975",9.99",4.995",1,45.2623) # epanda=ignore bpanda(18:13:20.811,+31:21:59.25,0.262262,270.262,3,13.32",6.66",19.98",9.99",1,45.2623) # text={Bpanda} bpanda(18:13:20.903,+31:21:29.94,45.2623,90.2623,1,13.32",6.66",19.98",9.99",1,45.2623) # bpanda=(45.2623 90.2623 180.262 270.262)(13.32" 6.66" 19.98" 9.99")(45.2623) text={Bpanda 2} bpanda(18:13:20.903,+31:21:29.94,90.2623,180.262,1,13.32",6.66",19.98",9.99",1,45.2623) # bpanda=ignore bpanda(18:13:20.903,+31:21:29.94,180.262,270.262,1,13.32",6.66",19.98",9.99",1,45.2623) # bpanda=ignore circle(18:13:51.995,+31:25:51.73,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(18:13:49.859,+31:25:46.24,13.32",6.66",45.2623) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(18:13:47.517,+31:25:45.76,26.64",13.32",45.2623) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(18:13:45.718,+31:25:49.57,18:13:44.741,+31:26:02.21,18:13:43.753,+31:25:49.72,18:13:44.729,+31:25:37.07) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(18:13:43.066,+31:25:41.45,18:13:41.513,+31:25:58.55) # line=1 1 color=cyan text={Line} # vector(18:13:40.624,+31:25:48.96,13.32",45.2623) vector=1 color=red text={Vector} # text(18:13:39.191,+31:25:44.40) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(18:13:46.223,+31:25:04.24,18:13:44.567,+31:25:24.01) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(18:13:51.977,+31:25:14.44,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(18:13:49.765,+31:25:13.28,4.995",2.4975",9.99",4.995",45.2623) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(18:13:47.502,+31:25:13.13,13.32",6.66",19.98",9.99",45.2623) # font="helvetica 10 bold roman" text={Box Annulus} point(18:13:52.144,+31:24:43.45) # point=circle text={Circle Point} point(18:13:49.828,+31:24:42.97) # point=box color=red width=3 text={Box Point} point(18:13:47.722,+31:24:43.81) # point=diamond text={Diamond Point} point(18:13:51.746,+31:24:27.17) # point=cross color=blue text={Cross Point} point(18:13:49.769,+31:24:27.66) # point=x text={X Point} point(18:13:47.766,+31:24:26.82) # point=arrow color=magenta text={Arrow Point} point(18:13:49.709,+31:24:10.35) # point=boxcircle text={BoxCircle Point} # projection(18:13:43.516,+31:25:01.12,18:13:41.107,+31:25:23.28,6.66") text={Projection} panda(18:13:45.147,+31:24:44.01,0.262262,270.262,3,0",9.99",2) # text={Panda} panda(18:13:45.080,+31:24:13.71,51.8442,90.2623,1,0",4.995",1) # panda=(51.8442 90.2623 180.262 270.262)(0" 4.995" 9.99") text={Panda 2} panda(18:13:45.080,+31:24:13.71,51.8442,90.2623,1,4.995",9.99",1) # panda=ignore panda(18:13:45.080,+31:24:13.71,90.2623,180.262,1,0",4.995",1) # panda=ignore panda(18:13:45.080,+31:24:13.71,90.2623,180.262,1,4.995",9.99",1) # panda=ignore panda(18:13:45.080,+31:24:13.71,180.262,270.262,1,0",4.995",1) # panda=ignore panda(18:13:45.080,+31:24:13.71,180.262,270.262,1,4.995",9.99",1) # panda=ignore # compass(18:13:40.345,+31:25:08.35,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(18:13:43.012,+31:24:41.51,0.262262,270.262,3,4.995",2.4975",9.99",4.995",1,45.2623) # text={Epanda} epanda(18:13:42.921,+31:24:11.88,45.2623,90.2623,1,4.995",2.4975",9.99",4.995",1,45.2623) # epanda=(45.2623 90.2623 180.262 270.262)(4.995" 2.4975" 9.99" 4.995")(45.2623) text={Epanda 2} epanda(18:13:42.921,+31:24:11.88,90.2623,180.262,1,4.995",2.4975",9.99",4.995",1,45.2623) # epanda=ignore epanda(18:13:42.921,+31:24:11.88,180.262,270.262,1,4.995",2.4975",9.99",4.995",1,45.2623) # epanda=ignore bpanda(18:13:40.749,+31:24:41.68,0.262262,270.262,3,13.32",6.66",19.98",9.99",1,45.2623) # text={Bpanda} bpanda(18:13:40.840,+31:24:12.37,45.2623,90.2623,1,13.32",6.66",19.98",9.99",1,45.2623) # bpanda=(45.2623 90.2623 180.262 270.262)(13.32" 6.66" 19.98" 9.99")(45.2623) text={Bpanda 2} bpanda(18:13:40.840,+31:24:12.37,90.2623,180.262,1,13.32",6.66",19.98",9.99",1,45.2623) # bpanda=ignore bpanda(18:13:40.840,+31:24:12.37,180.262,270.262,1,13.32",6.66",19.98",9.99",1,45.2623) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.mosaic.fk4.reg0000644000076600000240000001605013336761120023052 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 fk4 circle(273.38353,31.385947,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(273.37463,31.384417,13.32",6.66",45.262262) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(273.36488,31.384277,26.64",13.32",45.262262) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(273.35739,31.385329,273.35332,31.388839,273.3492,31.385365,273.35327,31.381855) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(273.34635,31.383066,273.33987,31.387812) # line=1 1 color=cyan text={Line} # vector(273.33617,31.385146,13.32",45.262262) vector=1 color=red text={Vector} # text(273.33021,31.383877) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(273.3595,31.372739,273.3526,31.378228) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(273.38346,31.375587,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(273.37425,31.375261,4.995",2.4975",9.99",4.995",45.262262) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(273.36482,31.375212,13.32",6.66",19.98",9.99",45.262262) # font="helvetica 10 bold roman" text={Box Annulus} point(273.38416,31.366981) # point=circle text={Circle Point} point(273.37452,31.366842) # point=box color=red width=3 text={Box Point} point(273.36575,31.367068) # point=diamond text={Diamond Point} point(273.38251,31.362457) # point=cross color=blue text={Cross Point} point(273.37428,31.362588) # point=x text={X Point} point(273.36594,31.362349) # point=arrow color=magenta text={Arrow Point} point(273.37403,31.357779) # point=boxcircle text={BoxCircle Point} # projection(273.34823,31.371865,273.33819,31.378014,6.66") text={Projection} panda(273.35502,31.367117,0.26226242,270.26226,3,0",9.99",2) # text={Panda} panda(273.35475,31.3587,51.844162,90.262262,1,0",4.995",1) # panda=(51.844162 90.262262 180.26226 270.26226)(0" 4.995" 9.99") text={Panda 2} panda(273.35475,31.3587,51.844162,90.262262,1,4.995",9.99",1) # panda=ignore panda(273.35475,31.3587,90.262262,180.26226,1,0",4.995",1) # panda=ignore panda(273.35475,31.3587,90.262262,180.26226,1,4.995",9.99",1) # panda=ignore panda(273.35475,31.3587,180.26226,270.26226,1,0",4.995",1) # panda=ignore panda(273.35475,31.3587,180.26226,270.26226,1,4.995",9.99",1) # panda=ignore # compass(273.33502,31.373866,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(273.34614,31.366416,0.26226242,270.26226,3,4.995",2.4975",9.99",4.995",1,45.262262) # text={Epanda} epanda(273.34576,31.358185,45.262262,90.262262,1,4.995",2.4975",9.99",4.995",1,45.262262) # epanda=(45.262262 90.262262 180.26226 270.26226)(4.995" 2.4975" 9.99" 4.995")(45.262262) text={Epanda 2} epanda(273.34576,31.358185,90.262262,180.26226,1,4.995",2.4975",9.99",4.995",1,45.262262) # epanda=ignore epanda(273.34576,31.358185,180.26226,270.26226,1,4.995",2.4975",9.99",4.995",1,45.262262) # epanda=ignore bpanda(273.33671,31.366458,0.26226242,270.26226,3,13.32",6.66",19.98",9.99",1,45.262262) # text={Bpanda} bpanda(273.3371,31.358316,45.262262,90.262262,1,13.32",6.66",19.98",9.99",1,45.262262) # bpanda=(45.262262 90.262262 180.26226 270.26226)(13.32" 6.66" 19.98" 9.99")(45.262262) text={Bpanda 2} bpanda(273.3371,31.358316,90.262262,180.26226,1,13.32",6.66",19.98",9.99",1,45.262262) # bpanda=ignore bpanda(273.3371,31.358316,180.26226,270.26226,1,13.32",6.66",19.98",9.99",1,45.262262) # bpanda=ignore circle(273.46665,31.431037,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(273.45775,31.429512,13.32",6.66",45.262262) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(273.44799,31.429379,26.64",13.32",45.262262) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(273.44049,31.430435,273.43642,31.433948,273.4323,31.430477,273.43637,31.426964) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(273.42944,31.428179,273.42297,31.43293) # line=1 1 color=cyan text={Line} # vector(273.41927,31.430266,13.32",45.262262) vector=1 color=red text={Vector} # text(273.4133,31.429001) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(273.44259,31.417844,273.4357,31.423337) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(273.46657,31.420677,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(273.45735,31.420357,4.995",2.4975",9.99",4.995",45.262262) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(273.44792,31.420314,13.32",6.66",19.98",9.99",45.262262) # font="helvetica 10 bold roman" text={Box Annulus} point(273.46727,31.412071) # point=circle text={Circle Point} point(273.45762,31.411937) # point=box color=red width=3 text={Box Point} point(273.44884,31.412169) # point=diamond text={Diamond Point} point(273.46561,31.407547) # point=cross color=blue text={Cross Point} point(273.45737,31.407684) # point=x text={X Point} point(273.44902,31.40745) # point=arrow color=magenta text={Arrow Point} point(273.45712,31.402875) # point=boxcircle text={BoxCircle Point} # projection(273.43132,31.416977,273.42128,31.423133,6.66") text={Projection} panda(273.43811,31.412225,0.26226242,270.26226,3,0",9.99",2) # text={Panda} panda(273.43783,31.403809,51.844162,90.262262,1,0",4.995",1) # panda=(51.844162 90.262262 180.26226 270.26226)(0" 4.995" 9.99") text={Panda 2} panda(273.43783,31.403809,51.844162,90.262262,1,4.995",9.99",1) # panda=ignore panda(273.43783,31.403809,90.262262,180.26226,1,0",4.995",1) # panda=ignore panda(273.43783,31.403809,90.262262,180.26226,1,4.995",9.99",1) # panda=ignore panda(273.43783,31.403809,180.26226,270.26226,1,0",4.995",1) # panda=ignore panda(273.43783,31.403809,180.26226,270.26226,1,4.995",9.99",1) # panda=ignore # compass(273.41811,31.418987,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(273.42922,31.41153,0.26226242,270.26226,3,4.995",2.4975",9.99",4.995",1,45.262262) # text={Epanda} epanda(273.42884,31.4033,45.262262,90.262262,1,4.995",2.4975",9.99",4.995",1,45.262262) # epanda=(45.262262 90.262262 180.26226 270.26226)(4.995" 2.4975" 9.99" 4.995")(45.262262) text={Epanda 2} epanda(273.42884,31.4033,90.262262,180.26226,1,4.995",2.4975",9.99",4.995",1,45.262262) # epanda=ignore epanda(273.42884,31.4033,180.26226,270.26226,1,4.995",2.4975",9.99",4.995",1,45.262262) # epanda=ignore bpanda(273.41979,31.411578,0.26226242,270.26226,3,13.32",6.66",19.98",9.99",1,45.262262) # text={Bpanda} bpanda(273.42017,31.403436,45.262262,90.262262,1,13.32",6.66",19.98",9.99",1,45.262262) # bpanda=(45.262262 90.262262 180.26226 270.26226)(13.32" 6.66" 19.98" 9.99")(45.262262) text={Bpanda 2} bpanda(273.42017,31.403436,90.262262,180.26226,1,13.32",6.66",19.98",9.99",1,45.262262) # bpanda=ignore bpanda(273.42017,31.403436,180.26226,270.26226,1,13.32",6.66",19.98",9.99",1,45.262262) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.mosaic.fk5.hms.reg0000644000076600000240000001643013336761120023643 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 fk5 circle(18:15:25.155,+31:24:12.71,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(18:15:23.022,+31:24:07.05,13.32",6.66",44.9398) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(18:15:20.681,+31:24:06.37,26.64",13.32",44.9398) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(18:15:18.880,+31:24:10.03,18:15:17.898,+31:24:22.59,18:15:16.916,+31:24:10.02,18:15:17.898,+31:23:57.45) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(18:15:16.234,+31:24:01.69,18:15:14.673,+31:24:18.66) # line=1 1 color=cyan text={Line} # vector(18:15:13.789,+31:24:09.00,13.32",44.9398) vector=1 color=red text={Vector} # text(18:15:12.358,+31:24:04.33) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(18:15:19.408,+31:23:24.74,18:15:17.743,+31:23:44.38) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(18:15:25.155,+31:23:35.41,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(18:15:22.945,+31:23:34.08,4.995",2.4975",9.99",4.995",44.9398) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(18:15:20.682,+31:23:33.74,13.32",6.66",19.98",9.99",44.9398) # font="helvetica 10 bold roman" text={Box Annulus} point(18:15:25.337,+31:23:04.45) # point=circle text={Circle Point} point(18:15:23.023,+31:23:03.78) # point=box color=red width=3 text={Box Point} point(18:15:20.917,+31:23:04.43) # point=diamond text={Diamond Point} point(18:15:24.948,+31:22:48.13) # point=cross color=blue text={Cross Point} point(18:15:22.971,+31:22:48.46) # point=x text={X Point} point(18:15:20.969,+31:22:47.45) # point=arrow color=magenta text={Arrow Point} point(18:15:22.920,+31:22:31.14) # point=boxcircle text={BoxCircle Point} # projection(18:15:16.703,+31:23:21.40,18:15:14.284,+31:23:43.36,6.66") text={Projection} panda(18:15:18.342,+31:23:04.42,359.94,629.94,3,0",9.99",2) # text={Panda} panda(18:15:18.291,+31:22:34.12,51.5217,89.9398,1,0",4.995",1) # panda=(51.5217 89.9398 179.94 269.94)(0" 4.995" 9.99") text={Panda 2} panda(18:15:18.291,+31:22:34.12,51.5217,89.9398,1,4.995",9.99",1) # panda=ignore panda(18:15:18.291,+31:22:34.12,89.9398,179.94,1,0",4.995",1) # panda=ignore panda(18:15:18.291,+31:22:34.12,89.9398,179.94,1,4.995",9.99",1) # panda=ignore panda(18:15:18.291,+31:22:34.12,179.94,269.94,1,0",4.995",1) # panda=ignore panda(18:15:18.291,+31:22:34.12,179.94,269.94,1,4.995",9.99",1) # panda=ignore # compass(18:15:13.530,+31:23:28.37,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(18:15:16.210,+31:23:01.75,359.94,629.94,3,4.995",2.4975",9.99",4.995",1,44.9398) # text={Epanda} epanda(18:15:16.133,+31:22:32.11,44.9398,89.9398,1,4.995",2.4975",9.99",4.995",1,44.9398) # epanda=(44.9398 89.9398 179.94 269.94)(4.995" 2.4975" 9.99" 4.995")(44.9398) text={Epanda 2} epanda(18:15:16.133,+31:22:32.11,89.9398,179.94,1,4.995",2.4975",9.99",4.995",1,44.9398) # epanda=ignore epanda(18:15:16.133,+31:22:32.11,179.94,269.94,1,4.995",2.4975",9.99",4.995",1,44.9398) # epanda=ignore bpanda(18:15:13.947,+31:23:01.73,359.94,629.94,3,13.32",6.66",19.98",9.99",1,44.9398) # text={Bpanda} bpanda(18:15:14.053,+31:22:32.43,44.9398,89.9398,1,13.32",6.66",19.98",9.99",1,44.9398) # bpanda=(44.9398 89.9398 179.94 269.94)(13.32" 6.66" 19.98" 9.99")(44.9398) text={Bpanda 2} bpanda(18:15:14.053,+31:22:32.43,89.9398,179.94,1,13.32",6.66",19.98",9.99",1,44.9398) # bpanda=ignore bpanda(18:15:14.053,+31:22:32.43,179.94,269.94,1,13.32",6.66",19.98",9.99",1,44.9398) # bpanda=ignore circle(18:15:45.034,+31:26:56.48,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(18:15:42.900,+31:26:50.84,13.32",6.66",44.9398) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(18:15:40.558,+31:26:50.19,26.64",13.32",44.9398) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(18:15:38.756,+31:26:53.86,18:15:37.774,+31:27:06.44,18:15:36.792,+31:26:53.87,18:15:37.774,+31:26:41.29) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(18:15:36.108,+31:26:45.55,18:15:34.547,+31:27:02.53) # line=1 1 color=cyan text={Line} # vector(18:15:33.663,+31:26:52.88,13.32",44.9398) vector=1 color=red text={Vector} # text(18:15:32.231,+31:26:48.22) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(18:15:39.282,+31:26:08.57,18:15:37.617,+31:26:28.22) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(18:15:45.033,+31:26:19.19,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(18:15:42.821,+31:26:17.87,4.995",2.4975",9.99",4.995",44.9398) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(18:15:40.557,+31:26:17.55,13.32",6.66",19.98",9.99",44.9398) # font="helvetica 10 bold roman" text={Box Annulus} point(18:15:45.213,+31:25:48.22) # point=circle text={Circle Point} point(18:15:42.898,+31:25:47.57) # point=box color=red width=3 text={Box Point} point(18:15:40.790,+31:25:48.25) # point=diamond text={Diamond Point} point(18:15:44.822,+31:25:31.90) # point=cross color=blue text={Cross Point} point(18:15:42.845,+31:25:32.25) # point=x text={X Point} point(18:15:40.842,+31:25:31.26) # point=arrow color=magenta text={Arrow Point} point(18:15:42.792,+31:25:14.93) # point=boxcircle text={BoxCircle Point} # projection(18:15:36.576,+31:26:05.25,18:15:34.157,+31:26:27.24,6.66") text={Projection} panda(18:15:38.215,+31:25:48.26,359.94,629.94,3,0",9.99",2) # text={Panda} panda(18:15:38.162,+31:25:17.96,51.5217,89.9398,1,0",4.995",1) # panda=(51.5217 89.9398 179.94 269.94)(0" 4.995" 9.99") text={Panda 2} panda(18:15:38.162,+31:25:17.96,51.5217,89.9398,1,4.995",9.99",1) # panda=ignore panda(18:15:38.162,+31:25:17.96,89.9398,179.94,1,0",4.995",1) # panda=ignore panda(18:15:38.162,+31:25:17.96,89.9398,179.94,1,4.995",9.99",1) # panda=ignore panda(18:15:38.162,+31:25:17.96,179.94,269.94,1,0",4.995",1) # panda=ignore panda(18:15:38.162,+31:25:17.96,179.94,269.94,1,4.995",9.99",1) # panda=ignore # compass(18:15:33.402,+31:26:12.25,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(18:15:36.081,+31:25:45.61,359.94,629.94,3,4.995",2.4975",9.99",4.995",1,44.9398) # text={Epanda} epanda(18:15:36.002,+31:25:15.97,44.9398,89.9398,1,4.995",2.4975",9.99",4.995",1,44.9398) # epanda=(44.9398 89.9398 179.94 269.94)(4.995" 2.4975" 9.99" 4.995")(44.9398) text={Epanda 2} epanda(18:15:36.002,+31:25:15.97,89.9398,179.94,1,4.995",2.4975",9.99",4.995",1,44.9398) # epanda=ignore epanda(18:15:36.002,+31:25:15.97,179.94,269.94,1,4.995",2.4975",9.99",4.995",1,44.9398) # epanda=ignore bpanda(18:15:33.818,+31:25:45.61,359.94,629.94,3,13.32",6.66",19.98",9.99",1,44.9398) # text={Bpanda} bpanda(18:15:33.921,+31:25:16.31,44.9398,89.9398,1,13.32",6.66",19.98",9.99",1,44.9398) # bpanda=(44.9398 89.9398 179.94 269.94)(13.32" 6.66" 19.98" 9.99")(44.9398) text={Bpanda 2} bpanda(18:15:33.921,+31:25:16.31,89.9398,179.94,1,13.32",6.66",19.98",9.99",1,44.9398) # bpanda=ignore bpanda(18:15:33.921,+31:25:16.31,179.94,269.94,1,13.32",6.66",19.98",9.99",1,44.9398) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.mosaic.fk5.reg0000644000076600000240000001606213336761120023056 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 fk5 circle(273.85481,31.403531,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(273.84593,31.401957,13.32",6.66",44.939783) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(273.83617,31.40177,26.64",13.32",44.939783) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(273.82867,31.402785,273.82457,31.406276,273.82048,31.402783,273.82458,31.399292) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(273.81764,31.400469,273.81114,31.405184) # line=1 1 color=cyan text={Line} # vector(273.80745,31.4025,13.32",44.939783) vector=1 color=red text={Vector} # text(273.80149,31.401202) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(273.83087,31.390206,273.82393,31.395661) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(273.85481,31.393171,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(273.8456,31.3928,4.995",2.4975",9.99",4.995",44.939783) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(273.83617,31.392705,13.32",6.66",19.98",9.99",44.939783) # font="helvetica 10 bold roman" text={Box Annulus} point(273.85557,31.384568) # point=circle text={Circle Point} point(273.84593,31.384382) # point=box color=red width=3 text={Box Point} point(273.83715,31.384565) # point=diamond text={Diamond Point} point(273.85395,31.380036) # point=cross color=blue text={Cross Point} point(273.84571,31.380127) # point=x text={X Point} point(273.83737,31.379848) # point=arrow color=magenta text={Arrow Point} point(273.8455,31.375317) # point=boxcircle text={BoxCircle Point} # projection(273.8196,31.389277,273.80952,31.395378,6.66") text={Projection} panda(273.82643,31.384562,359.93978,629.93978,3,0",9.99",2) # text={Panda} panda(273.82621,31.376145,51.521683,89.939783,1,0",4.995",1) # panda=(51.521683 89.939783 179.93978 269.93978)(0" 4.995" 9.99") text={Panda 2} panda(273.82621,31.376145,51.521683,89.939783,1,4.995",9.99",1) # panda=ignore panda(273.82621,31.376145,89.939783,179.93978,1,0",4.995",1) # panda=ignore panda(273.82621,31.376145,89.939783,179.93978,1,4.995",9.99",1) # panda=ignore panda(273.82621,31.376145,179.93978,269.93978,1,0",4.995",1) # panda=ignore panda(273.82621,31.376145,179.93978,269.93978,1,4.995",9.99",1) # panda=ignore # compass(273.80638,31.391214,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(273.81754,31.383819,359.93978,629.93978,3,4.995",2.4975",9.99",4.995",1,44.939783) # text={Epanda} epanda(273.81722,31.375586,44.939783,89.939783,1,4.995",2.4975",9.99",4.995",1,44.939783) # epanda=(44.939783 89.939783 179.93978 269.93978)(4.995" 2.4975" 9.99" 4.995")(44.939783) text={Epanda 2} epanda(273.81722,31.375586,89.939783,179.93978,1,4.995",2.4975",9.99",4.995",1,44.939783) # epanda=ignore epanda(273.81722,31.375586,179.93978,269.93978,1,4.995",2.4975",9.99",4.995",1,44.939783) # epanda=ignore bpanda(273.80811,31.383815,359.93978,629.93978,3,13.32",6.66",19.98",9.99",1,44.939783) # text={Bpanda} bpanda(273.80855,31.375675,44.939783,89.939783,1,13.32",6.66",19.98",9.99",1,44.939783) # bpanda=(44.939783 89.939783 179.93978 269.93978)(13.32" 6.66" 19.98" 9.99")(44.939783) text={Bpanda 2} bpanda(273.80855,31.375675,89.939783,179.93978,1,13.32",6.66",19.98",9.99",1,44.939783) # bpanda=ignore bpanda(273.80855,31.375675,179.93978,269.93978,1,13.32",6.66",19.98",9.99",1,44.939783) # bpanda=ignore circle(273.93764,31.449023,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(273.92875,31.447455,13.32",6.66",44.939783) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(273.91899,31.447274,26.64",13.32",44.939783) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(273.91149,31.448294,273.90739,31.451788,273.9033,31.448297,273.90739,31.444803) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(273.90045,31.445985,273.89395,31.450704) # line=1 1 color=cyan text={Line} # vector(273.89026,31.448022,13.32",44.939783) vector=1 color=red text={Vector} # text(273.8843,31.446728) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(273.91367,31.435713,273.90674,31.441173) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(273.93764,31.438663,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(273.92842,31.438297,4.995",2.4975",9.99",4.995",44.939783) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(273.91899,31.438209,13.32",6.66",19.98",9.99",44.939783) # font="helvetica 10 bold roman" text={Box Annulus} point(273.93839,31.43006) # point=circle text={Circle Point} point(273.92874,31.42988) # point=box color=red width=3 text={Box Point} point(273.91996,31.430069) # point=diamond text={Diamond Point} point(273.93676,31.425528) # point=cross color=blue text={Cross Point} point(273.92852,31.425625) # point=x text={X Point} point(273.92017,31.425351) # point=arrow color=magenta text={Arrow Point} point(273.9283,31.420815) # point=boxcircle text={BoxCircle Point} # projection(273.9024,31.434792,273.89232,31.440899,6.66") text={Projection} panda(273.90923,31.430072,359.93978,629.93978,3,0",9.99",2) # text={Panda} panda(273.90901,31.421655,51.521683,89.939783,1,0",4.995",1) # panda=(51.521683 89.939783 179.93978 269.93978)(0" 4.995" 9.99") text={Panda 2} panda(273.90901,31.421655,51.521683,89.939783,1,4.995",9.99",1) # panda=ignore panda(273.90901,31.421655,89.939783,179.93978,1,0",4.995",1) # panda=ignore panda(273.90901,31.421655,89.939783,179.93978,1,4.995",9.99",1) # panda=ignore panda(273.90901,31.421655,179.93978,269.93978,1,0",4.995",1) # panda=ignore panda(273.90901,31.421655,179.93978,269.93978,1,4.995",9.99",1) # panda=ignore # compass(273.88917,31.436737,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(273.90034,31.429335,359.93978,629.93978,3,4.995",2.4975",9.99",4.995",1,44.939783) # text={Epanda} epanda(273.90001,31.421103,44.939783,89.939783,1,4.995",2.4975",9.99",4.995",1,44.939783) # epanda=(44.939783 89.939783 179.93978 269.93978)(4.995" 2.4975" 9.99" 4.995")(44.939783) text={Epanda 2} epanda(273.90001,31.421103,89.939783,179.93978,1,4.995",2.4975",9.99",4.995",1,44.939783) # epanda=ignore epanda(273.90001,31.421103,179.93978,269.93978,1,4.995",2.4975",9.99",4.995",1,44.939783) # epanda=ignore bpanda(273.89091,31.429337,359.93978,629.93978,3,13.32",6.66",19.98",9.99",1,44.939783) # text={Bpanda} bpanda(273.89134,31.421197,44.939783,89.939783,1,13.32",6.66",19.98",9.99",1,44.939783) # bpanda=(44.939783 89.939783 179.93978 269.93978)(13.32" 6.66" 19.98" 9.99")(44.939783) text={Bpanda 2} bpanda(273.89134,31.421197,89.939783,179.93978,1,13.32",6.66",19.98",9.99",1,44.939783) # bpanda=ignore bpanda(273.89134,31.421197,179.93978,269.93978,1,13.32",6.66",19.98",9.99",1,44.939783) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.mosaic.galactic.hms.reg0000644000076600000240000001676113336761120024734 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 galactic circle(+58:28:21.331,+20:53:04.817,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(+58:28:05.723,+20:53:28.587,13.32",6.66",115.143) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(+58:27:54.177,+20:53:56.556,26.64",13.32",115.143) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(+58:27:49.497,+20:54:19.492,+58:27:57.595,+20:54:35.581,+58:27:40.371,+20:54:43.146,+58:27:32.273,+20:54:27.056) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(+58:27:28.814,+20:54:48.546,+58:27:38.666,+20:55:13.101) # line=1 1 color=cyan text={Line} # vector(+58:27:24.830,+20:55:20.478,13.32",115.143) vector=1 color=red text={Vector} # text(+58:27:13.486,+20:55:36.127) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(+58:27:06.337,+20:53:57.793,+58:27:18.386,+20:54:24.505) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(+58:27:43.777,+20:52:52.173,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(+58:27:32.164,+20:53:18.350,4.995",2.4975",9.99",4.995",115.143) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(+58:27:21.314,+20:53:45.492,13.32",6.66",19.98",9.99",115.143) # font="helvetica 10 bold roman" text={Box Annulus} point(+58:27:13.441,+20:52:39.479) # point=circle text={Circle Point} point(+58:27:02.014,+20:53:07.134) # point=box color=red width=3 text={Box Point} point(+58:26:52.894,+20:53:32.735) # point=diamond text={Diamond Point} point(+58:26:55.199,+20:52:38.645) # point=cross color=blue text={Cross Point} point(+58:26:46.348,+20:53:02.566) # point=x text={X Point} point(+58:26:36.035,+20:53:26.349) # point=arrow color=magenta text={Arrow Point} point(+58:26:28.672,+20:52:57.320) # point=boxcircle text={BoxCircle Point} # projection(+58:26:50.412,+20:54:29.243,+58:27:01.303,+20:55:05.831,6.66") text={Projection} panda(+58:26:40.926,+20:54:03.748,70.1434,340.143,3,0",9.99",2) # text={Panda} panda(+58:26:10.170,+20:53:54.097,121.725,160.143,1,0",4.995",1) # panda=(121.725 160.143 250.143 340.143)(0" 4.995" 9.99") text={Panda 2} panda(+58:26:10.170,+20:53:54.097,121.725,160.143,1,4.995",9.99",1) # panda=ignore panda(+58:26:10.170,+20:53:54.097,160.143,250.143,1,0",4.995",1) # panda=ignore panda(+58:26:10.170,+20:53:54.097,160.143,250.143,1,4.995",9.99",1) # panda=ignore panda(+58:26:10.170,+20:53:54.097,250.143,340.143,1,0",4.995",1) # panda=ignore panda(+58:26:10.170,+20:53:54.097,250.143,340.143,1,4.995",9.99",1) # panda=ignore # compass(+58:26:42.705,+20:55:09.833,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(+58:26:28.330,+20:54:28.532,70.1434,340.143,3,4.995",2.4975",9.99",4.995",1,115.143) # text={Epanda} epanda(+58:25:58.122,+20:54:19.419,115.143,160.143,1,4.995",2.4975",9.99",4.995",1,115.143) # epanda=(115.143 160.143 250.143 340.143)(4.995" 2.4975" 9.99" 4.995")(115.143) text={Epanda 2} epanda(+58:25:58.122,+20:54:19.419,160.143,250.143,1,4.995",2.4975",9.99",4.995",1,115.143) # epanda=ignore epanda(+58:25:58.122,+20:54:19.419,250.143,340.143,1,4.995",2.4975",9.99",4.995",1,115.143) # epanda=ignore bpanda(+58:26:17.810,+20:54:55.786,70.1434,340.143,3,13.32",6.66",19.98",9.99",1,115.143) # text={Bpanda} bpanda(+58:25:48.783,+20:54:44.592,115.143,160.143,1,13.32",6.66",19.98",9.99",1,115.143) # bpanda=(115.143 160.143 250.143 340.143)(13.32" 6.66" 19.98" 9.99")(115.143) text={Bpanda 2} bpanda(+58:25:48.783,+20:54:44.592,160.143,250.143,1,13.32",6.66",19.98",9.99",1,115.143) # bpanda=ignore bpanda(+58:25:48.783,+20:54:44.592,250.143,340.143,1,13.32",6.66",19.98",9.99",1,115.143) # bpanda=ignore circle(+58:32:38.525,+20:50:00.954,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(+58:32:22.933,+20:50:24.730,13.32",6.66",115.143) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(+58:32:11.404,+20:50:52.704,26.64",13.32",115.143) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(+58:32:06.737,+20:51:15.642,+58:32:14.840,+20:51:31.728,+58:31:57.626,+20:51:39.299,+58:31:49.523,+20:51:23.213) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(+58:31:46.075,+20:51:44.704,+58:31:55.935,+20:52:09.255) # line=1 1 color=cyan text={Line} # vector(+58:31:42.108,+20:52:16.637,13.32",115.143) vector=1 color=red text={Vector} # text(+58:31:30.774,+20:52:32.291) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(+58:31:23.582,+20:50:53.961,+58:31:35.640,+20:51:20.667) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(+58:32:00.978,+20:49:48.325,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(+58:31:49.381,+20:50:14.507,4.995",2.4975",9.99",4.995",115.143) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(+58:31:38.547,+20:50:41.653,13.32",6.66",19.98",9.99",115.143) # font="helvetica 10 bold roman" text={Box Annulus} point(+58:31:30.646,+20:49:35.644) # point=circle text={Circle Point} point(+58:31:19.236,+20:50:03.304) # point=box color=red width=3 text={Box Point} point(+58:31:10.131,+20:50:28.908) # point=diamond text={Diamond Point} point(+58:31:12.410,+20:49:34.817) # point=cross color=blue text={Cross Point} point(+58:31:03.573,+20:49:58.742) # point=x text={X Point} point(+58:30:53.275,+20:50:22.529) # point=arrow color=magenta text={Arrow Point} point(+58:30:45.900,+20:49:53.503) # point=boxcircle text={BoxCircle Point} # projection(+58:31:07.677,+20:51:25.418,+58:31:18.581,+20:52:02.000,6.66") text={Projection} panda(+58:30:58.182,+20:50:59.926,70.1434,340.143,3,0",9.99",2) # text={Panda} panda(+58:30:27.432,+20:50:50.288,121.725,160.143,1,0",4.995",1) # panda=(121.725 160.143 250.143 340.143)(0" 4.995" 9.99") text={Panda 2} panda(+58:30:27.432,+20:50:50.288,121.725,160.143,1,4.995",9.99",1) # panda=ignore panda(+58:30:27.432,+20:50:50.288,160.143,250.143,1,0",4.995",1) # panda=ignore panda(+58:30:27.432,+20:50:50.288,160.143,250.143,1,4.995",9.99",1) # panda=ignore panda(+58:30:27.432,+20:50:50.288,250.143,340.143,1,0",4.995",1) # panda=ignore panda(+58:30:27.432,+20:50:50.288,250.143,340.143,1,4.995",9.99",1) # panda=ignore # compass(+58:30:59.992,+20:52:06.011,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(+58:30:45.602,+20:51:24.716,70.1434,340.143,3,4.995",2.4975",9.99",4.995",1,115.143) # text={Epanda} epanda(+58:30:15.400,+20:51:15.615,115.143,160.143,1,4.995",2.4975",9.99",4.995",1,115.143) # epanda=(115.143 160.143 250.143 340.143)(4.995" 2.4975" 9.99" 4.995")(115.143) text={Epanda 2} epanda(+58:30:15.400,+20:51:15.615,160.143,250.143,1,4.995",2.4975",9.99",4.995",1,115.143) # epanda=ignore epanda(+58:30:15.400,+20:51:15.615,250.143,340.143,1,4.995",2.4975",9.99",4.995",1,115.143) # epanda=ignore bpanda(+58:30:35.099,+20:51:51.974,70.1434,340.143,3,13.32",6.66",19.98",9.99",1,115.143) # text={Bpanda} bpanda(+58:30:06.076,+20:51:40.792,115.143,160.143,1,13.32",6.66",19.98",9.99",1,115.143) # bpanda=(115.143 160.143 250.143 340.143)(13.32" 6.66" 19.98" 9.99")(115.143) text={Bpanda 2} bpanda(+58:30:06.076,+20:51:40.792,160.143,250.143,1,13.32",6.66",19.98",9.99",1,115.143) # bpanda=ignore bpanda(+58:30:06.076,+20:51:40.792,250.143,340.143,1,13.32",6.66",19.98",9.99",1,115.143) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.mosaic.galactic.reg0000644000076600000240000001605713336761120024144 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 galactic circle(58.472592,20.884671,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(58.468256,20.891274,13.32",6.66",115.14338) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(58.465049,20.899043,26.64",13.32",115.14338) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(58.463749,20.905414,58.465999,20.909884,58.461214,20.911985,58.458965,20.907516) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(58.458004,20.913485,58.460741,20.920306) # line=1 1 color=cyan text={Line} # vector(58.456897,20.922355,13.32",115.14338) vector=1 color=red text={Vector} # text(58.453746,20.926702) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(58.45176,20.899387,58.455107,20.906807) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(58.46216,20.881159,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(58.458934,20.88843,4.995",2.4975",9.99",4.995",115.14338) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(58.455921,20.89597,13.32",6.66",19.98",9.99",115.14338) # font="helvetica 10 bold roman" text={Box Annulus} point(58.453734,20.877633) # point=circle text={Circle Point} point(58.450559,20.885315) # point=box color=red width=3 text={Box Point} point(58.448026,20.892426) # point=diamond text={Diamond Point} point(58.448666,20.877401) # point=cross color=blue text={Cross Point} point(58.446208,20.884046) # point=x text={X Point} point(58.443343,20.890652) # point=arrow color=magenta text={Arrow Point} point(58.441298,20.882589) # point=boxcircle text={BoxCircle Point} # projection(58.447337,20.908123,58.450362,20.918286,6.66") text={Projection} panda(58.444702,20.901041,70.143383,340.14338,3,0",9.99",2) # text={Panda} panda(58.436158,20.89836,121.72528,160.14338,1,0",4.995",1) # panda=(121.72528 160.14338 250.14338 340.14338)(0" 4.995" 9.99") text={Panda 2} panda(58.436158,20.89836,121.72528,160.14338,1,4.995",9.99",1) # panda=ignore panda(58.436158,20.89836,160.14338,250.14338,1,0",4.995",1) # panda=ignore panda(58.436158,20.89836,160.14338,250.14338,1,4.995",9.99",1) # panda=ignore panda(58.436158,20.89836,250.14338,340.14338,1,0",4.995",1) # panda=ignore panda(58.436158,20.89836,250.14338,340.14338,1,4.995",9.99",1) # panda=ignore # compass(58.445196,20.919398,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(58.441203,20.907926,70.143383,340.14338,3,4.995",2.4975",9.99",4.995",1,115.14338) # text={Epanda} epanda(58.432812,20.905394,115.14338,160.14338,1,4.995",2.4975",9.99",4.995",1,115.14338) # epanda=(115.14338 160.14338 250.14338 340.14338)(4.995" 2.4975" 9.99" 4.995")(115.14338) text={Epanda 2} epanda(58.432812,20.905394,160.14338,250.14338,1,4.995",2.4975",9.99",4.995",1,115.14338) # epanda=ignore epanda(58.432812,20.905394,250.14338,340.14338,1,4.995",2.4975",9.99",4.995",1,115.14338) # epanda=ignore bpanda(58.438281,20.915496,70.143383,340.14338,3,13.32",6.66",19.98",9.99",1,115.14338) # text={Bpanda} bpanda(58.430218,20.912387,115.14338,160.14338,1,13.32",6.66",19.98",9.99",1,115.14338) # bpanda=(115.14338 160.14338 250.14338 340.14338)(13.32" 6.66" 19.98" 9.99")(115.14338) text={Bpanda 2} bpanda(58.430218,20.912387,160.14338,250.14338,1,13.32",6.66",19.98",9.99",1,115.14338) # bpanda=ignore bpanda(58.430218,20.912387,250.14338,340.14338,1,13.32",6.66",19.98",9.99",1,115.14338) # bpanda=ignore circle(58.544035,20.833598,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(58.539704,20.840203,13.32",6.66",115.14338) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(58.536501,20.847973,26.64",13.32",115.14338) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(58.535205,20.854345,58.537456,20.858813,58.532674,20.860917,58.530423,20.856448) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(58.529465,20.862418,58.532204,20.869237) # line=1 1 color=cyan text={Line} # vector(58.528363,20.871288,13.32",115.14338) vector=1 color=red text={Vector} # text(58.525215,20.875636) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(58.523217,20.848322,58.526567,20.855741) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(58.533605,20.83009,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(58.530384,20.837363,4.995",2.4975",9.99",4.995",115.14338) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(58.527374,20.844904,13.32",6.66",19.98",9.99",115.14338) # font="helvetica 10 bold roman" text={Box Annulus} point(58.525179,20.826568) # point=circle text={Circle Point} point(58.52201,20.834251) # point=box color=red width=3 text={Box Point} point(58.519481,20.841363) # point=diamond text={Diamond Point} point(58.520114,20.826338) # point=cross color=blue text={Cross Point} point(58.517659,20.832984) # point=x text={X Point} point(58.514798,20.839591) # point=arrow color=magenta text={Arrow Point} point(58.51275,20.831529) # point=boxcircle text={BoxCircle Point} # projection(58.518799,20.85706,58.521828,20.867222,6.66") text={Projection} panda(58.516162,20.84998,70.143383,340.14338,3,0",9.99",2) # text={Panda} panda(58.50762,20.847302,121.72528,160.14338,1,0",4.995",1) # panda=(121.72528 160.14338 250.14338 340.14338)(0" 4.995" 9.99") text={Panda 2} panda(58.50762,20.847302,121.72528,160.14338,1,4.995",9.99",1) # panda=ignore panda(58.50762,20.847302,160.14338,250.14338,1,0",4.995",1) # panda=ignore panda(58.50762,20.847302,160.14338,250.14338,1,4.995",9.99",1) # panda=ignore panda(58.50762,20.847302,250.14338,340.14338,1,0",4.995",1) # panda=ignore panda(58.50762,20.847302,250.14338,340.14338,1,4.995",9.99",1) # panda=ignore # compass(58.516664,20.868336,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(58.512667,20.856865,70.143383,340.14338,3,4.995",2.4975",9.99",4.995",1,115.14338) # text={Epanda} epanda(58.504278,20.854338,115.14338,160.14338,1,4.995",2.4975",9.99",4.995",1,115.14338) # epanda=(115.14338 160.14338 250.14338 340.14338)(4.995" 2.4975" 9.99" 4.995")(115.14338) text={Epanda 2} epanda(58.504278,20.854338,160.14338,250.14338,1,4.995",2.4975",9.99",4.995",1,115.14338) # epanda=ignore epanda(58.504278,20.854338,250.14338,340.14338,1,4.995",2.4975",9.99",4.995",1,115.14338) # epanda=ignore bpanda(58.50975,20.864437,70.143383,340.14338,3,13.32",6.66",19.98",9.99",1,115.14338) # text={Bpanda} bpanda(58.501688,20.861331,115.14338,160.14338,1,13.32",6.66",19.98",9.99",1,115.14338) # bpanda=(115.14338 160.14338 250.14338 340.14338)(13.32" 6.66" 19.98" 9.99")(115.14338) text={Bpanda 2} bpanda(58.501688,20.861331,160.14338,250.14338,1,13.32",6.66",19.98",9.99",1,115.14338) # bpanda=ignore bpanda(58.501688,20.861331,250.14338,340.14338,1,13.32",6.66",19.98",9.99",1,115.14338) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.mosaic.icrs.hms.reg0000644000076600000240000001643113336761120024117 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 icrs circle(18:15:25.154,+31:24:12.69,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(18:15:23.021,+31:24:07.03,13.32",6.66",44.9398) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(18:15:20.680,+31:24:06.35,26.64",13.32",44.9398) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(18:15:18.879,+31:24:10.01,18:15:17.897,+31:24:22.57,18:15:16.915,+31:24:10.00,18:15:17.897,+31:23:57.43) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(18:15:16.233,+31:24:01.67,18:15:14.671,+31:24:18.64) # line=1 1 color=cyan text={Line} # vector(18:15:13.787,+31:24:08.98,13.32",44.9398) vector=1 color=red text={Vector} # text(18:15:12.357,+31:24:04.31) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(18:15:19.407,+31:23:24.72,18:15:17.742,+31:23:44.36) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(18:15:25.154,+31:23:35.39,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(18:15:22.943,+31:23:34.06,4.995",2.4975",9.99",4.995",44.9398) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(18:15:20.681,+31:23:33.72,13.32",6.66",19.98",9.99",44.9398) # font="helvetica 10 bold roman" text={Box Annulus} point(18:15:25.336,+31:23:04.43) # point=circle text={Circle Point} point(18:15:23.022,+31:23:03.76) # point=box color=red width=3 text={Box Point} point(18:15:20.915,+31:23:04.41) # point=diamond text={Diamond Point} point(18:15:24.946,+31:22:48.11) # point=cross color=blue text={Cross Point} point(18:15:22.970,+31:22:48.44) # point=x text={X Point} point(18:15:20.968,+31:22:47.43) # point=arrow color=magenta text={Arrow Point} point(18:15:22.918,+31:22:31.12) # point=boxcircle text={BoxCircle Point} # projection(18:15:16.702,+31:23:21.38,18:15:14.283,+31:23:43.34,6.66") text={Projection} panda(18:15:18.341,+31:23:04.40,359.94,629.94,3,0",9.99",2) # text={Panda} panda(18:15:18.290,+31:22:34.10,51.5217,89.9398,1,0",4.995",1) # panda=(51.5217 89.9398 179.94 269.94)(0" 4.995" 9.99") text={Panda 2} panda(18:15:18.290,+31:22:34.10,51.5217,89.9398,1,4.995",9.99",1) # panda=ignore panda(18:15:18.290,+31:22:34.10,89.9398,179.94,1,0",4.995",1) # panda=ignore panda(18:15:18.290,+31:22:34.10,89.9398,179.94,1,4.995",9.99",1) # panda=ignore panda(18:15:18.290,+31:22:34.10,179.94,269.94,1,0",4.995",1) # panda=ignore panda(18:15:18.290,+31:22:34.10,179.94,269.94,1,4.995",9.99",1) # panda=ignore # compass(18:15:13.529,+31:23:28.35,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(18:15:16.209,+31:23:01.73,359.94,629.94,3,4.995",2.4975",9.99",4.995",1,44.9398) # text={Epanda} epanda(18:15:16.132,+31:22:32.09,44.9398,89.9398,1,4.995",2.4975",9.99",4.995",1,44.9398) # epanda=(44.9398 89.9398 179.94 269.94)(4.995" 2.4975" 9.99" 4.995")(44.9398) text={Epanda 2} epanda(18:15:16.132,+31:22:32.09,89.9398,179.94,1,4.995",2.4975",9.99",4.995",1,44.9398) # epanda=ignore epanda(18:15:16.132,+31:22:32.09,179.94,269.94,1,4.995",2.4975",9.99",4.995",1,44.9398) # epanda=ignore bpanda(18:15:13.946,+31:23:01.71,359.94,629.94,3,13.32",6.66",19.98",9.99",1,44.9398) # text={Bpanda} bpanda(18:15:14.052,+31:22:32.41,44.9398,89.9398,1,13.32",6.66",19.98",9.99",1,44.9398) # bpanda=(44.9398 89.9398 179.94 269.94)(13.32" 6.66" 19.98" 9.99")(44.9398) text={Bpanda 2} bpanda(18:15:14.052,+31:22:32.41,89.9398,179.94,1,13.32",6.66",19.98",9.99",1,44.9398) # bpanda=ignore bpanda(18:15:14.052,+31:22:32.41,179.94,269.94,1,13.32",6.66",19.98",9.99",1,44.9398) # bpanda=ignore circle(18:15:45.033,+31:26:56.46,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(18:15:42.899,+31:26:50.82,13.32",6.66",44.9398) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(18:15:40.557,+31:26:50.17,26.64",13.32",44.9398) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(18:15:38.755,+31:26:53.84,18:15:37.773,+31:27:06.42,18:15:36.790,+31:26:53.85,18:15:37.773,+31:26:41.27) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(18:15:36.107,+31:26:45.53,18:15:34.546,+31:27:02.51) # line=1 1 color=cyan text={Line} # vector(18:15:33.661,+31:26:52.86,13.32",44.9398) vector=1 color=red text={Vector} # text(18:15:32.230,+31:26:48.20) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(18:15:39.281,+31:26:08.55,18:15:37.616,+31:26:28.20) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(18:15:45.031,+31:26:19.17,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(18:15:42.820,+31:26:17.85,4.995",2.4975",9.99",4.995",44.9398) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(18:15:40.556,+31:26:17.53,13.32",6.66",19.98",9.99",44.9398) # font="helvetica 10 bold roman" text={Box Annulus} point(18:15:45.212,+31:25:48.20) # point=circle text={Circle Point} point(18:15:42.896,+31:25:47.55) # point=box color=red width=3 text={Box Point} point(18:15:40.789,+31:25:48.23) # point=diamond text={Diamond Point} point(18:15:44.821,+31:25:31.88) # point=cross color=blue text={Cross Point} point(18:15:42.844,+31:25:32.23) # point=x text={X Point} point(18:15:40.841,+31:25:31.24) # point=arrow color=magenta text={Arrow Point} point(18:15:42.791,+31:25:14.91) # point=boxcircle text={BoxCircle Point} # projection(18:15:36.575,+31:26:05.23,18:15:34.155,+31:26:27.22,6.66") text={Projection} panda(18:15:38.213,+31:25:48.24,359.94,629.94,3,0",9.99",2) # text={Panda} panda(18:15:38.160,+31:25:17.94,51.5217,89.9398,1,0",4.995",1) # panda=(51.5217 89.9398 179.94 269.94)(0" 4.995" 9.99") text={Panda 2} panda(18:15:38.160,+31:25:17.94,51.5217,89.9398,1,4.995",9.99",1) # panda=ignore panda(18:15:38.160,+31:25:17.94,89.9398,179.94,1,0",4.995",1) # panda=ignore panda(18:15:38.160,+31:25:17.94,89.9398,179.94,1,4.995",9.99",1) # panda=ignore panda(18:15:38.160,+31:25:17.94,179.94,269.94,1,0",4.995",1) # panda=ignore panda(18:15:38.160,+31:25:17.94,179.94,269.94,1,4.995",9.99",1) # panda=ignore # compass(18:15:33.401,+31:26:12.23,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(18:15:36.080,+31:25:45.59,359.94,629.94,3,4.995",2.4975",9.99",4.995",1,44.9398) # text={Epanda} epanda(18:15:36.001,+31:25:15.95,44.9398,89.9398,1,4.995",2.4975",9.99",4.995",1,44.9398) # epanda=(44.9398 89.9398 179.94 269.94)(4.995" 2.4975" 9.99" 4.995")(44.9398) text={Epanda 2} epanda(18:15:36.001,+31:25:15.95,89.9398,179.94,1,4.995",2.4975",9.99",4.995",1,44.9398) # epanda=ignore epanda(18:15:36.001,+31:25:15.95,179.94,269.94,1,4.995",2.4975",9.99",4.995",1,44.9398) # epanda=ignore bpanda(18:15:33.816,+31:25:45.59,359.94,629.94,3,13.32",6.66",19.98",9.99",1,44.9398) # text={Bpanda} bpanda(18:15:33.920,+31:25:16.29,44.9398,89.9398,1,13.32",6.66",19.98",9.99",1,44.9398) # bpanda=(44.9398 89.9398 179.94 269.94)(13.32" 6.66" 19.98" 9.99")(44.9398) text={Bpanda 2} bpanda(18:15:33.920,+31:25:16.29,89.9398,179.94,1,13.32",6.66",19.98",9.99",1,44.9398) # bpanda=ignore bpanda(18:15:33.920,+31:25:16.29,179.94,269.94,1,13.32",6.66",19.98",9.99",1,44.9398) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.mosaic.icrs.reg0000644000076600000240000001603613336761120023332 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 icrs circle(273.85481,31.403525,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(273.84592,31.401951,13.32",6.66",44.939786) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(273.83617,31.401764,26.64",13.32",44.939786) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(273.82866,31.40278,273.82457,31.406271,273.82048,31.402777,273.82457,31.399286) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(273.81764,31.400463,273.81113,31.405178) # line=1 1 color=cyan text={Line} # vector(273.80745,31.402494,13.32",44.939786) vector=1 color=red text={Vector} # text(273.80149,31.401196) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(273.83086,31.3902,273.82392,31.395656) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(273.85481,31.393165,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(273.8456,31.392794,4.995",2.4975",9.99",4.995",44.939786) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(273.83617,31.392699,13.32",6.66",19.98",9.99",44.939786) # font="helvetica 10 bold roman" text={Box Annulus} point(273.85557,31.384563) # point=circle text={Circle Point} point(273.84592,31.384376) # point=box color=red width=3 text={Box Point} point(273.83715,31.38456) # point=diamond text={Diamond Point} point(273.85394,31.38003) # point=cross color=blue text={Cross Point} point(273.84571,31.380121) # point=x text={X Point} point(273.83737,31.379842) # point=arrow color=magenta text={Arrow Point} point(273.84549,31.375311) # point=boxcircle text={BoxCircle Point} # projection(273.81959,31.389272,273.80951,31.395372,6.66") text={Projection} panda(273.82642,31.384557,359.93979,629.93979,3,0",9.99",2) # text={Panda} panda(273.82621,31.376139,51.521686,89.939786,1,0",4.995",1) # panda=(51.521686 89.939786 179.93979 269.93979)(0" 4.995" 9.99") text={Panda 2} panda(273.82621,31.376139,51.521686,89.939786,1,4.995",9.99",1) # panda=ignore panda(273.82621,31.376139,89.939786,179.93979,1,0",4.995",1) # panda=ignore panda(273.82621,31.376139,89.939786,179.93979,1,4.995",9.99",1) # panda=ignore panda(273.82621,31.376139,179.93979,269.93979,1,0",4.995",1) # panda=ignore panda(273.82621,31.376139,179.93979,269.93979,1,4.995",9.99",1) # panda=ignore # compass(273.80637,31.391209,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(273.81754,31.383813,359.93979,629.93979,3,4.995",2.4975",9.99",4.995",1,44.939786) # text={Epanda} epanda(273.81722,31.375581,44.939786,89.939786,1,4.995",2.4975",9.99",4.995",1,44.939786) # epanda=(44.939786 89.939786 179.93979 269.93979)(4.995" 2.4975" 9.99" 4.995")(44.939786) text={Epanda 2} epanda(273.81722,31.375581,89.939786,179.93979,1,4.995",2.4975",9.99",4.995",1,44.939786) # epanda=ignore epanda(273.81722,31.375581,179.93979,269.93979,1,4.995",2.4975",9.99",4.995",1,44.939786) # epanda=ignore bpanda(273.80811,31.383809,359.93979,629.93979,3,13.32",6.66",19.98",9.99",1,44.939786) # text={Bpanda} bpanda(273.80855,31.37567,44.939786,89.939786,1,13.32",6.66",19.98",9.99",1,44.939786) # bpanda=(44.939786 89.939786 179.93979 269.93979)(13.32" 6.66" 19.98" 9.99")(44.939786) text={Bpanda 2} bpanda(273.80855,31.37567,89.939786,179.93979,1,13.32",6.66",19.98",9.99",1,44.939786) # bpanda=ignore bpanda(273.80855,31.37567,179.93979,269.93979,1,13.32",6.66",19.98",9.99",1,44.939786) # bpanda=ignore circle(273.93764,31.449017,6.66") # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(273.92875,31.447449,13.32",6.66",44.939786) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(273.91899,31.447268,26.64",13.32",44.939786) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(273.91148,31.448289,273.90739,31.451782,273.90329,31.448291,273.90739,31.444798) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(273.90045,31.445979,273.89394,31.450698) # line=1 1 color=cyan text={Line} # vector(273.89026,31.448016,13.32",44.939786) vector=1 color=red text={Vector} # text(273.88429,31.446722) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(273.91367,31.435708,273.90673,31.441168) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(273.93763,31.438657,3.33",6.66",9.99") # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(273.92842,31.438292,4.995",2.4975",9.99",4.995",44.939786) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(273.91898,31.438203,13.32",6.66",19.98",9.99",44.939786) # font="helvetica 10 bold roman" text={Box Annulus} point(273.93838,31.430054) # point=circle text={Circle Point} point(273.92874,31.429874) # point=box color=red width=3 text={Box Point} point(273.91995,31.430063) # point=diamond text={Diamond Point} point(273.93675,31.425523) # point=cross color=blue text={Cross Point} point(273.92852,31.425619) # point=x text={X Point} point(273.92017,31.425345) # point=arrow color=magenta text={Arrow Point} point(273.9283,31.420809) # point=boxcircle text={BoxCircle Point} # projection(273.90239,31.434786,273.89231,31.440894,6.66") text={Projection} panda(273.90922,31.430067,359.93979,629.93979,3,0",9.99",2) # text={Panda} panda(273.909,31.421649,51.521686,89.939786,1,0",4.995",1) # panda=(51.521686 89.939786 179.93979 269.93979)(0" 4.995" 9.99") text={Panda 2} panda(273.909,31.421649,51.521686,89.939786,1,4.995",9.99",1) # panda=ignore panda(273.909,31.421649,89.939786,179.93979,1,0",4.995",1) # panda=ignore panda(273.909,31.421649,89.939786,179.93979,1,4.995",9.99",1) # panda=ignore panda(273.909,31.421649,179.93979,269.93979,1,0",4.995",1) # panda=ignore panda(273.909,31.421649,179.93979,269.93979,1,4.995",9.99",1) # panda=ignore # compass(273.88917,31.436732,13.32") compass=physical {N} {E} 1 1 text={Compass} epanda(273.90033,31.429329,359.93979,629.93979,3,4.995",2.4975",9.99",4.995",1,44.939786) # text={Epanda} epanda(273.9,31.421097,44.939786,89.939786,1,4.995",2.4975",9.99",4.995",1,44.939786) # epanda=(44.939786 89.939786 179.93979 269.93979)(4.995" 2.4975" 9.99" 4.995")(44.939786) text={Epanda 2} epanda(273.9,31.421097,89.939786,179.93979,1,4.995",2.4975",9.99",4.995",1,44.939786) # epanda=ignore epanda(273.9,31.421097,179.93979,269.93979,1,4.995",2.4975",9.99",4.995",1,44.939786) # epanda=ignore bpanda(273.8909,31.429331,359.93979,629.93979,3,13.32",6.66",19.98",9.99",1,44.939786) # text={Bpanda} bpanda(273.89133,31.421191,44.939786,89.939786,1,13.32",6.66",19.98",9.99",1,44.939786) # bpanda=(44.939786 89.939786 179.93979 269.93979)(13.32" 6.66" 19.98" 9.99")(44.939786) text={Bpanda 2} bpanda(273.89133,31.421191,89.939786,179.93979,1,13.32",6.66",19.98",9.99",1,44.939786) # bpanda=ignore bpanda(273.89133,31.421191,179.93979,269.93979,1,13.32",6.66",19.98",9.99",1,44.939786) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.mosaic.image.reg0000644000076600000240000001315213336761120023450 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 image # tile 1 circle(97,1963,20) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 1 -ellipse(179,1946,40,20,45) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 1 -box(269,1944,80,40,45) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 1 polygon(338.24723,1955,376,1992.7528,413.75277,1955,376,1917.2472) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 1 -line(440,1930,500,1981) # line=1 1 color=cyan text={Line} # tile 1 # vector(534,1952,40,45) vector=1 color=red text={Vector} # tile 1 # text(589,1938) color=magenta font="helvetica 14 bold roman" text={Region} # tile 1 # ruler(318,1819,382,1878) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 1 annulus(97,1851,10,20,30) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 1 ellipse(182,1847,15,7.5,30,15,45) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 1 box(269,1846,40,20,60,30,45) # font="helvetica 10 bold roman" text={Box Annulus} # tile 1 point(90,1758) # point=circle text={Circle Point} # tile 1 point(179,1756) # point=box color=red width=3 text={Box Point} # tile 1 point(260,1758) # point=diamond text={Diamond Point} # tile 1 point(105,1709) # point=cross color=blue text={Cross Point} # tile 1 point(181,1710) # point=x text={X Point} # tile 1 point(258,1707) # point=arrow color=magenta text={Arrow Point} # tile 1 point(183,1658) # point=boxcircle text={BoxCircle Point} # tile 1 # projection(422,1809,515,1875,20) text={Projection} # tile 1 panda(359,1758,0,270,3,0,30,2) # text={Panda} # tile 1 panda(361,1667,51.5819,90,1,0,15,1) # panda=(51.5819 90 180 270)(0 15 30) text={Panda 2} # tile 1 panda(361,1667,51.5819,90,1,15,30,1) # panda=ignore # tile 1 panda(361,1667,90,180,1,0,15,1) # panda=ignore # tile 1 panda(361,1667,90,180,1,15,30,1) # panda=ignore # tile 1 panda(361,1667,180,270,1,0,15,1) # panda=ignore # tile 1 panda(361,1667,180,270,1,15,30,1) # panda=ignore # tile 1 # compass(544,1830,40) compass=physical {N} {E} 1 1 text={Compass} # tile 1 epanda(441,1750,0,270,3,15,7.5,30,15,1,45) # text={Epanda} # tile 1 epanda(444,1661,45,90,1,15,7.5,30,15,1,45) # epanda=(45 90 180 270)(15 7.5 30 15)(45) text={Epanda 2} # tile 1 epanda(444,1661,90,180,1,15,7.5,30,15,1,45) # epanda=ignore # tile 1 epanda(444,1661,180,270,1,15,7.5,30,15,1,45) # epanda=ignore # tile 1 bpanda(528,1750,0,270,3,40,20,60,30,1,45) # text={Bpanda} # tile 1 bpanda(524,1662,45,90,1,40,20,60,30,1,45) # bpanda=(45 90 180 270)(40 20 60 30)(45) text={Bpanda 2} # tile 1 bpanda(524,1662,90,180,1,40,20,60,30,1,45) # bpanda=ignore # tile 1 bpanda(524,1662,180,270,1,40,20,60,30,1,45) # bpanda=ignore # tile 3 circle(1465,363,20) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 3 -ellipse(1547,346,40,20,45) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 3 -box(1637,344,80,40,45) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 3 polygon(1706.2472,355,1744,392.75275,1781.7528,355,1744,317.24723) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 3 -line(1808,330,1868,381) # line=1 1 color=cyan text={Line} # tile 3 # vector(1902,352,40,45) vector=1 color=red text={Vector} # tile 3 # text(1957,338) color=magenta font="helvetica 14 bold roman" text={Region} # tile 3 # ruler(1686,219,1750,278) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 3 annulus(1465,251,10,20,30) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 3 ellipse(1550,247,15,7.5,30,15,45) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 3 box(1637,246,40,20,60,30,45) # font="helvetica 10 bold roman" text={Box Annulus} # tile 3 point(1458,158) # point=circle text={Circle Point} # tile 3 point(1547,156) # point=box color=red width=3 text={Box Point} # tile 3 point(1628,158) # point=diamond text={Diamond Point} # tile 3 point(1473,109) # point=cross color=blue text={Cross Point} # tile 3 point(1549,110) # point=x text={X Point} # tile 3 point(1626,107) # point=arrow color=magenta text={Arrow Point} # tile 3 point(1551,58) # point=boxcircle text={BoxCircle Point} # tile 3 # projection(1790,209,1883,275,20) text={Projection} # tile 3 panda(1727,158,0,270,3,0,30,2) # text={Panda} # tile 3 panda(1729,67,51.5819,90,1,0,15,1) # panda=(51.5819 90 180 270)(0 15 30) text={Panda 2} # tile 3 panda(1729,67,51.5819,90,1,15,30,1) # panda=ignore # tile 3 panda(1729,67,90,180,1,0,15,1) # panda=ignore # tile 3 panda(1729,67,90,180,1,15,30,1) # panda=ignore # tile 3 panda(1729,67,180,270,1,0,15,1) # panda=ignore # tile 3 panda(1729,67,180,270,1,15,30,1) # panda=ignore # tile 3 # compass(1912,230,40) compass=physical {N} {E} 1 1 text={Compass} # tile 3 epanda(1809,150,0,270,3,15,7.5,30,15,1,45) # text={Epanda} # tile 3 epanda(1812,61,45,90,1,15,7.5,30,15,1,45) # epanda=(45 90 180 270)(15 7.5 30 15)(45) text={Epanda 2} # tile 3 epanda(1812,61,90,180,1,15,7.5,30,15,1,45) # epanda=ignore # tile 3 epanda(1812,61,180,270,1,15,7.5,30,15,1,45) # epanda=ignore # tile 3 bpanda(1896,150,0,270,3,40,20,60,30,1,45) # text={Bpanda} # tile 3 bpanda(1892,62,45,90,1,40,20,60,30,1,45) # bpanda=(45 90 180 270)(40 20 60 30)(45) text={Bpanda 2} # tile 3 bpanda(1892,62,90,180,1,40,20,60,30,1,45) # bpanda=ignore # tile 3 bpanda(1892,62,180,270,1,40,20,60,30,1,45) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.mosaic.physical.reg0000644000076600000240000001315113336761120024201 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 physical # tile 1 circle(66,1963,20) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 1 -ellipse(148,1946,40,20,45) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 1 -box(238,1944,80,40,45) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 1 polygon(307.24723,1955,345,1992.7528,382.75277,1955,345,1917.2472) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 1 -line(409,1930,469,1981) # line=1 1 color=cyan text={Line} # tile 1 # vector(503,1952,40,45) vector=1 color=red text={Vector} # tile 1 # text(558,1938) color=magenta font="helvetica 14 bold roman" text={Region} # tile 1 # ruler(287,1819,351,1878) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 1 annulus(66,1851,10,20,30) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 1 ellipse(151,1847,15,7.5,30,15,45) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 1 box(238,1846,40,20,60,30,45) # font="helvetica 10 bold roman" text={Box Annulus} # tile 1 point(59,1758) # point=circle text={Circle Point} # tile 1 point(148,1756) # point=box color=red width=3 text={Box Point} # tile 1 point(229,1758) # point=diamond text={Diamond Point} # tile 1 point(74,1709) # point=cross color=blue text={Cross Point} # tile 1 point(150,1710) # point=x text={X Point} # tile 1 point(227,1707) # point=arrow color=magenta text={Arrow Point} # tile 1 point(152,1658) # point=boxcircle text={BoxCircle Point} # tile 1 # projection(391,1809,484,1875,20) text={Projection} # tile 1 panda(328,1758,0,270,3,0,30,2) # text={Panda} # tile 1 panda(330,1667,51.5819,90,1,0,15,1) # panda=(51.5819 90 180 270)(0 15 30) text={Panda 2} # tile 1 panda(330,1667,51.5819,90,1,15,30,1) # panda=ignore # tile 1 panda(330,1667,90,180,1,0,15,1) # panda=ignore # tile 1 panda(330,1667,90,180,1,15,30,1) # panda=ignore # tile 1 panda(330,1667,180,270,1,0,15,1) # panda=ignore # tile 1 panda(330,1667,180,270,1,15,30,1) # panda=ignore # tile 1 # compass(513,1830,40) compass=physical {N} {E} 1 1 text={Compass} # tile 1 epanda(410,1750,0,270,3,15,7.5,30,15,1,45) # text={Epanda} # tile 1 epanda(413,1661,45,90,1,15,7.5,30,15,1,45) # epanda=(45 90 180 270)(15 7.5 30 15)(45) text={Epanda 2} # tile 1 epanda(413,1661,90,180,1,15,7.5,30,15,1,45) # epanda=ignore # tile 1 epanda(413,1661,180,270,1,15,7.5,30,15,1,45) # epanda=ignore # tile 1 bpanda(497,1750,0,270,3,40,20,60,30,1,45) # text={Bpanda} # tile 1 bpanda(493,1662,45,90,1,40,20,60,30,1,45) # bpanda=(45 90 180 270)(40 20 60 30)(45) text={Bpanda 2} # tile 1 bpanda(493,1662,90,180,1,40,20,60,30,1,45) # bpanda=ignore # tile 1 bpanda(493,1662,180,270,1,40,20,60,30,1,45) # bpanda=ignore # tile 3 circle(1464,347,20) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment # tile 3 -ellipse(1546,330,40,20,45) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background # tile 3 -box(1636,328,80,40,45) # color=yellow font="helvetica 10 bold roman" text={Box} # tile 3 polygon(1705.2472,339,1743,376.75275,1780.7528,339,1743,301.24723) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 # tile 3 -line(1807,314,1867,365) # line=1 1 color=cyan text={Line} # tile 3 # vector(1901,336,40,45) vector=1 color=red text={Vector} # tile 3 # text(1956,322) color=magenta font="helvetica 14 bold roman" text={Region} # tile 3 # ruler(1685,203,1749,262) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} # tile 3 annulus(1464,235,10,20,30) # color=magenta font="helvetica 10 bold roman" text={Annulus} # tile 3 ellipse(1549,231,15,7.5,30,15,45) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} # tile 3 box(1636,230,40,20,60,30,45) # font="helvetica 10 bold roman" text={Box Annulus} # tile 3 point(1457,142) # point=circle text={Circle Point} # tile 3 point(1546,140) # point=box color=red width=3 text={Box Point} # tile 3 point(1627,142) # point=diamond text={Diamond Point} # tile 3 point(1472,93) # point=cross color=blue text={Cross Point} # tile 3 point(1548,94) # point=x text={X Point} # tile 3 point(1625,91) # point=arrow color=magenta text={Arrow Point} # tile 3 point(1550,42) # point=boxcircle text={BoxCircle Point} # tile 3 # projection(1789,193,1882,259,20) text={Projection} # tile 3 panda(1726,142,0,270,3,0,30,2) # text={Panda} # tile 3 panda(1728,51,51.5819,90,1,0,15,1) # panda=(51.5819 90 180 270)(0 15 30) text={Panda 2} # tile 3 panda(1728,51,51.5819,90,1,15,30,1) # panda=ignore # tile 3 panda(1728,51,90,180,1,0,15,1) # panda=ignore # tile 3 panda(1728,51,90,180,1,15,30,1) # panda=ignore # tile 3 panda(1728,51,180,270,1,0,15,1) # panda=ignore # tile 3 panda(1728,51,180,270,1,15,30,1) # panda=ignore # tile 3 # compass(1911,214,40) compass=physical {N} {E} 1 1 text={Compass} # tile 3 epanda(1808,134,0,270,3,15,7.5,30,15,1,45) # text={Epanda} # tile 3 epanda(1811,45,45,90,1,15,7.5,30,15,1,45) # epanda=(45 90 180 270)(15 7.5 30 15)(45) text={Epanda 2} # tile 3 epanda(1811,45,90,180,1,15,7.5,30,15,1,45) # epanda=ignore # tile 3 epanda(1811,45,180,270,1,15,7.5,30,15,1,45) # epanda=ignore # tile 3 bpanda(1895,134,0,270,3,40,20,60,30,1,45) # text={Bpanda} # tile 3 bpanda(1891,46,45,90,1,40,20,60,30,1,45) # bpanda=(45 90 180 270)(40 20 60 30)(45) text={Bpanda 2} # tile 3 bpanda(1891,46,90,180,1,40,20,60,30,1,45) # bpanda=ignore # tile 3 bpanda(1891,46,180,270,1,40,20,60,30,1,45) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/ds9.physical.reg0000644000076600000240000000535613336761120022737 0ustar deilstaff00000000000000# Region file format: DS9 version 4.1 global color=green dashlist=8 3 width=1 font="helvetica 10 normal roman" select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 include=1 source=1 physical circle(331,1091,40) # color=pink width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(495,1057,80,40,45) # color=#0ff font="helvetica 10 normal italic" text={Ellipse} background -box(675,1053,160,80,45) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(813.49446,1075,889,1150.5055,964.50554,1075,889,999.49446) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(1017,1025,1137,1127) # line=1 1 color=cyan text={Line} # vector(1205,1069,80,45) vector=1 color=red text={Vector} text(1315,1041) # color=magenta font="helvetica 14 bold roman" text={Region} # ruler(773,803,901,921) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(331,867,20,40,60) # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(501,859,30,15,60,30,45) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(675,857,80,40,120,60,45) # font="helvetica 10 bold roman" text={Box Annulus} point(317,681) # point=circle text={Circle Point} point(495,677) # point=box color=red width=3 text={Box Point} point(657,681) # point=diamond text={Diamond Point} point(347,583) # point=cross color=blue text={Cross Point} point(499,585) # point=x text={X Point} point(653,579) # point=arrow color=magenta text={Arrow Point} point(503,481) # point=boxcircle text={BoxCircle Point} # projection(981,783,1167,915,40) text={Projection} panda(855,681,0,270,3,0,60,2) # text={Panda} panda(859,499,51.5819,90,1,0,30,1) # panda=(51.5819 90 180 270)(0 30 60) text={Panda 2} panda(859,499,51.5819,90,1,30,60,1) # panda=ignore panda(859,499,90,180,1,0,30,1) # panda=ignore panda(859,499,90,180,1,30,60,1) # panda=ignore panda(859,499,180,270,1,0,30,1) # panda=ignore panda(859,499,180,270,1,30,60,1) # panda=ignore # compass(1225,825,80) compass=physical {N} {E} 1 1 text={Compass} epanda(1019,665,0,270,3,30,15,60,30,1,45) # text={Epanda} epanda(1025,487,45,90,1,30,15,60,30,1,45) # epanda=(45 90 180 270)(30 15 60 30)(45) text={Epanda 2} epanda(1025,487,90,180,1,30,15,60,30,1,45) # epanda=ignore epanda(1025,487,180,270,1,30,15,60,30,1,45) # epanda=ignore bpanda(1193,665,0,270,3,80,40,120,60,1,45) # text={Bpanda} bpanda(1185,489,45,90,1,80,40,120,60,1,45) # bpanda=(45 90 180 270)(80 40 120 60)(45) text={Bpanda 2} bpanda(1185,489,90,180,1,80,40,120,60,1,45) # bpanda=ignore bpanda(1185,489,180,270,1,80,40,120,60,1,45) # bpanda=ignore # segment(1336.9946,1154.9931,1364.9942,1074.9929,1416.9942,1074.9927) text={Segment} point(248,339) # point=box 14 color=red width=3 text={Box Point} regions-0.4/regions/io/ds9/tests/data/ds9.physical.strip.reg0000644000076600000240000000165713336761120024077 0ustar deilstaff00000000000000physical;circle(331,1091,40);-ellipse(495,1057,80,40,45);-box(675,1053,160,80,45);polygon(813.49446,1075,889,1150.5055,964.50554,1075,889,999.49446);-line(1017,1025,1137,1127);annulus(331,867,20,40,60);ellipse(501,859,30,15,60,30,45);box(675,857,80,40,120,60,45);point(317,681);point(495,677);point(657,681);point(347,583);point(499,585);point(653,579);point(503,481);panda(855,681,0,270,3,0,60,2);panda(859,499,51.5819,90,1,0,30,1);panda(859,499,51.5819,90,1,30,60,1);panda(859,499,90,180,1,0,30,1);panda(859,499,90,180,1,30,60,1);panda(859,499,180,270,1,0,30,1);panda(859,499,180,270,1,30,60,1);epanda(1019,665,0,270,3,30,15,60,30,1,45);epanda(1025,487,45,90,1,30,15,60,30,1,45);epanda(1025,487,90,180,1,30,15,60,30,1,45);epanda(1025,487,180,270,1,30,15,60,30,1,45);bpanda(1193,665,0,270,3,80,40,120,60,1,45);bpanda(1185,489,45,90,1,80,40,120,60,1,45);bpanda(1185,489,90,180,1,80,40,120,60,1,45);bpanda(1185,489,180,270,1,80,40,120,60,1,45);regions-0.4/regions/io/ds9/tests/data/ds9.physical.windows.reg0000644000076600000240000000517213336761120024424 0ustar deilstaff00000000000000# Region file format: DS9 version 4.0 global color=green font="helvetica 10 normal roman" select=1 highlite=1 edit=1 move=1 delete=1 include=1 fixed=0 source physical circle(325,1075,40) # color=red width=3 font="times 10 normal roman" text={Circle} tag={foo} tag={foo bar} This is a Comment -ellipse(489,1041,80,40,45) # color=cyan font="helvetica 10 normal italic" text={Ellipse} background -box(669,1037,160,80,45) # color=yellow font="helvetica 10 bold roman" text={Box} polygon(807.49446,1059,883,1134.5055,958.50554,1059,883,983.49446) # font="courier 10 normal roman" text={Polygon} edit=0 rotate=0 -line(1011,1009,1131,1111) # line=1 1 color=cyan text={Line} # vector(1199,1053,80,45) vector=1 color=red text={Vector} # text(1309,1025) color=magenta font="helvetica 14 bold roman" text={Region} # ruler(767,787,895,905) ruler=physical physical color=white font="helvetica 12 normal roman" text={Ruler} annulus(325,851,20,40,60) # color=magenta font="helvetica 10 bold roman" text={Annulus} ellipse(495,843,30,15,60,30,45) # color=red width=3 font="helvetica 10 bold roman" text={Ellipse Annulus} box(669,841,80,40,120,60,45) # font="helvetica 10 bold roman" text={Box Annulus} point(311,665) # point=circle text={Circle Point} point(489,661) # point=box color=red width=3 text={Box Point} point(651,665) # point=diamond text={Diamond Point} point(341,567) # point=cross color=blue text={Cross Point} point(493,569) # point=x text={X Point} point(647,563) # point=arrow color=magenta text={Arrow Point} point(497,465) # point=boxcircle text={BoxCircle Point} # projection(975,767,1161,899,40) text={Projection} panda(849,665,0,270,3,0,60,2) # text={Panda} panda(853,483,51.5819,90,1,0,30,1) || # panda=(51.5819 90 180 270)(0 30 60) text={Panda 2} panda(853,483,51.5819,90,1,30,60,1) || # panda=ignore panda(853,483,90,180,1,0,30,1) || # panda=ignore panda(853,483,90,180,1,30,60,1) || # panda=ignore panda(853,483,180,270,1,0,30,1) || # panda=ignore panda(853,483,180,270,1,30,60,1) # panda=ignore # compass(1219,809,80) compass=physical {N} {E} 1 1 text={Compass} epanda(1013,649,0,270,3,30,15,60,30,1,45) # text={Epanda} epanda(1019,471,45,90,1,30,15,60,30,1,45) || # epanda=(45 90 180 270)(30 15 60 30)(45) text={Epanda 2} epanda(1019,471,90,180,1,30,15,60,30,1,45) || # epanda=ignore epanda(1019,471,180,270,1,30,15,60,30,1,45) # epanda=ignore bpanda(1187,649,0,270,3,80,40,120,60,1,45) # text={Bpanda} bpanda(1179,473,45,90,1,80,40,120,60,1,45) || # bpanda=(45 90 180 270)(80 40 120 60)(45) text={Bpanda 2} bpanda(1179,473,90,180,1,80,40,120,60,1,45) || # bpanda=ignore bpanda(1179,473,180,270,1,80,40,120,60,1,45) # bpanda=ignore regions-0.4/regions/io/ds9/tests/data/fk5_reference.reg0000644000076600000240000000524213336761120023122 0ustar deilstaff00000000000000# Region file format: DS9 astropy/regions fk5 circle(202.49,47.21,3.96") # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Circle} tag={foo} tag={foo bar} This is a Comment color=pink width=3 font="times 10 normal roman" -ellipse(202.48,47.20,7.93",3.96",2.40) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Ellipse} background color=#0ff width=1 font="helvetica 10 normal italic" -box(202.48,47.20,15.86",7.93",2.40) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Box} color=yellow width=1 font="helvetica 10 bold roman" polygon(202.47,47.20,202.47,47.20,202.47,47.20,202.47,47.20) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=0 move=1 delete=1 source=1 text={Polygon} rotate=0 color=green width=1 font="courier 10 normal roman" -line(202.47,47.19,202.46,47.19) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 line=1 1 text={Line} color=cyan width=1 font="helvetica 10 normal roman" annulus(202.49,47.20,1.98",3.96") # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Annulus} color=magenta width=1 font="helvetica 10 bold roman" box(202.48,47.20,7.93",3.96",0.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Box Annulus} color=green width=1 font="helvetica 10 bold roman" point(202.50,47.20) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Circle Point} color=green width=1 font="helvetica 10 normal roman" point=circle point(202.49,47.20) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Box Point} color=red width=3 font="helvetica 10 normal roman" point=box point(202.49,47.19) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Diamond Point} color=green width=1 font="helvetica 10 normal roman" point=diamond point(202.50,47.20) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Cross Point} color=blue width=1 font="helvetica 10 normal roman" point=cross point(202.50,47.20) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={X Point} color=green width=1 font="helvetica 10 normal roman" point=x point(202.49,47.19) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Arrow Point} color=magenta width=1 font="helvetica 10 normal roman" point=arrow point(202.50,47.19) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={BoxCircle Point} color=green width=1 font="helvetica 10 normal roman" point=boxcircle regions-0.4/regions/io/ds9/tests/data/fk5_strip_reference.reg0000644000076600000240000000070513336761120024342 0ustar deilstaff00000000000000# Region file format: DS9 astropy/regions fk5 circle(202.49,47.21,3.96") -ellipse(202.48,47.20,7.93",3.96",2.40) -box(202.48,47.20,15.86",7.93",2.40) polygon(202.47,47.20,202.47,47.20,202.47,47.20,202.47,47.20) -line(202.47,47.19,202.46,47.19) annulus(202.49,47.20,1.98",3.96") box(202.48,47.20,7.93",3.96",0.00) point(202.50,47.20) point(202.49,47.20) point(202.49,47.19) point(202.50,47.20) point(202.50,47.20) point(202.49,47.19) point(202.50,47.19) regions-0.4/regions/io/ds9/tests/data/galactic_reference.reg0000644000076600000240000000525313336761120024206 0ustar deilstaff00000000000000# Region file format: DS9 astropy/regions galactic circle(104.84,68.54,3.96") # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Circle} tag={foo} tag={foo bar} This is a Comment color=pink width=3 font="times 10 normal roman" -ellipse(104.84,68.55,7.93",3.96",158.39) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Ellipse} background color=#0ff width=1 font="helvetica 10 normal italic" -box(104.85,68.55,15.86",7.93",158.39) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Box} color=yellow width=1 font="helvetica 10 bold roman" polygon(104.85,68.56,104.86,68.56,104.86,68.56,104.85,68.56) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=0 move=1 delete=1 source=1 text={Polygon} rotate=0 color=green width=1 font="courier 10 normal roman" -line(104.85,68.56,104.86,68.56) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 line=1 1 text={Line} color=cyan width=1 font="helvetica 10 normal roman" annulus(104.82,68.55,1.98",3.96") # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Annulus} color=magenta width=1 font="helvetica 10 bold roman" box(104.83,68.56,7.93",3.96",0.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Box Annulus} color=green width=1 font="helvetica 10 bold roman" point(104.81,68.55) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Circle Point} color=green width=1 font="helvetica 10 normal roman" point=circle point(104.81,68.55) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Box Point} color=red width=3 font="helvetica 10 normal roman" point=box point(104.82,68.56) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Diamond Point} color=green width=1 font="helvetica 10 normal roman" point=diamond point(104.80,68.55) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Cross Point} color=blue width=1 font="helvetica 10 normal roman" point=cross point(104.81,68.55) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={X Point} color=green width=1 font="helvetica 10 normal roman" point=x point(104.81,68.56) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Arrow Point} color=magenta width=1 font="helvetica 10 normal roman" point=arrow point(104.80,68.56) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={BoxCircle Point} color=green width=1 font="helvetica 10 normal roman" point=boxcircle regions-0.4/regions/io/ds9/tests/data/galactic_strip_reference.reg0000644000076600000240000000071613336761120025426 0ustar deilstaff00000000000000# Region file format: DS9 astropy/regions galactic circle(104.84,68.54,3.96") -ellipse(104.84,68.55,7.93",3.96",158.39) -box(104.85,68.55,15.86",7.93",158.39) polygon(104.85,68.56,104.86,68.56,104.86,68.56,104.85,68.56) -line(104.85,68.56,104.86,68.56) annulus(104.82,68.55,1.98",3.96") box(104.83,68.56,7.93",3.96",0.00) point(104.81,68.55) point(104.81,68.55) point(104.82,68.56) point(104.80,68.55) point(104.81,68.55) point(104.81,68.56) point(104.80,68.56) regions-0.4/regions/io/ds9/tests/data/physical_reference.reg0000644000076600000240000000605213336761120024251 0ustar deilstaff00000000000000# Region file format: DS9 astropy/regions physical circle(331.00,1091.00,40.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Circle} tag={foo} tag={foo bar} This is a Comment color=pink width=3 font="times 10 normal roman" -ellipse(495.00,1057.00,80.00,40.00,45.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Ellipse} background color=#0ff width=1 font="helvetica 10 normal italic" -box(675.00,1053.00,160.00,80.00,45.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Box} color=yellow width=1 font="helvetica 10 bold roman" polygon(813.49,1075.00,889.00,1150.51,964.51,1075.00,889.00,999.49) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=0 move=1 delete=1 source=1 text={Polygon} rotate=0 color=green width=1 font="courier 10 normal roman" -line(1017.00,1025.00,1137.00,1127.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 line=1 1 text={Line} color=cyan width=1 font="helvetica 10 normal roman" annulus(331.00,867.00,20.00,40.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Annulus} color=magenta width=1 font="helvetica 10 bold roman" box(675.00,857.00,80.00,40.00,120.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Box Annulus} color=green width=1 font="helvetica 10 bold roman" point(317.00,681.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Circle Point} color=green width=1 font="helvetica 10 normal roman" point=circle point(495.00,677.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Box Point} color=red width=3 font="helvetica 10 normal roman" point=box point(657.00,681.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Diamond Point} color=green width=1 font="helvetica 10 normal roman" point=diamond point(347.00,583.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Cross Point} color=blue width=1 font="helvetica 10 normal roman" point=cross point(499.00,585.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={X Point} color=green width=1 font="helvetica 10 normal roman" point=x point(653.00,579.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={Arrow Point} color=magenta width=1 font="helvetica 10 normal roman" point=arrow point(503.00,481.00) # dashlist=8 3 select=1 highlite=1 dash=0 fixed=0 edit=1 move=1 delete=1 source=1 text={BoxCircle Point} color=green width=1 font="helvetica 10 normal roman" point=boxcircle text(1315.00,1041.00) # select=1 highlite=1 fixed=0 edit=1 move=1 delete=1 source=1 color=magenta dashlist=8 3 width=1 dash=0 font="helvetica 14 bold roman" text={Region} point(248.00,339.00) # select=1 highlite=1 fixed=0 edit=1 move=1 delete=1 source=1 color=red dashlist=8 3 width=3 dash=0 point=box 14 font="helvetica 10 normal roman" text={Box Point} regions-0.4/regions/io/ds9/tests/data/physical_strip_reference.reg0000644000076600000240000000075213336761120025473 0ustar deilstaff00000000000000# Region file format: DS9 astropy/regions physical circle(331.00,1091.00,40.00) -ellipse(495.00,1057.00,80.00,40.00,45.00) -box(675.00,1053.00,160.00,80.00,45.00) polygon(813.49,1075.00,889.00,1150.51,964.51,1075.00,889.00,999.49) -line(1017.00,1025.00,1137.00,1127.00) annulus(331.00,867.00,20.00,40.00) box(675.00,857.00,80.00,40.00,120.00) point(317.00,681.00) point(495.00,677.00) point(657.00,681.00) point(347.00,583.00) point(499.00,585.00) point(653.00,579.00) point(503.00,481.00) regions-0.4/regions/io/ds9/tests/data/plot_image.reg0000644000076600000240000000151513501414013022524 0ustar deilstaff00000000000000# Region file format: DS9 astropy/regions image circle(501.000000,601.000000,50.000000) # color=red line(401.000000,201.000000,501.000000,101.000000) # color=blue point(101.000000,801.000000) # point=cross color=orange point(101.000000,101.000000) # point=x color=brown point(101.000000,301.000000) # point=boxcircle color=yellow point(101.000000,401.000000) # point=x color=violet point(101.000000,201.000000) # color=red ellipse(301.000000,751.000000,45.000000,30.000000,75.000000) # color=blue text(151.000000,551.000000) # text={Text} textangle=45 color=orange font="algeria 12 normal roman" annulus(651.000000,301.000000,60.000000,90.000000) # color=brown polygon(451.000000,751.000000,451.000000,701.000000,551.000000,651.000000,601.000000,751.000000) # color=yellow box(401.000000,401.000000,100.000000,80.000000,0.000000) # color=violet regions-0.4/regions/io/ds9/tests/test_ds9_language.py0000644000076600000240000002405713477731541023001 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import os import distutils.version as vers from numpy.testing import assert_allclose import pytest from astropy.utils.data import get_pkg_data_filename, get_pkg_data_filenames import astropy.version as astrov from astropy.coordinates import Angle, SkyCoord from astropy.tests.helper import catch_warnings, assert_quantity_allclose from astropy.utils.exceptions import AstropyUserWarning from astropy import units as u from ....shapes.circle import CircleSkyRegion from ..read import read_ds9, DS9Parser from ..write import write_ds9, ds9_objects_to_string _ASTROPY_MINVERSION = vers.LooseVersion('1.1') _ASTROPY_VERSION = vers.LooseVersion(astrov.version) @pytest.mark.xfail(_ASTROPY_VERSION < _ASTROPY_MINVERSION, reason='Some coordinates systems not available in older version of astropy') def test_read(): # Check that all test files including reference files are readable files = get_pkg_data_filenames('data') for f in files: with open(f) as f: DS9Parser(f.read(), errors='warn') implemented_region_types = ('ellipse', 'circle', 'rectangle', 'polygon', 'point') @pytest.mark.parametrize('filename', ['data/ds9.fk5.reg', 'data/ds9.fk5.hms.reg', 'data/ds9.fk5.hms.strip.reg', 'data/ds9.fk5.strip.reg', 'data/ds9.galactic.reg', 'data/ds9.galactic.hms.reg', 'data/ds9.galactic.hms.strip.reg', 'data/ds9.galactic.strip.reg', # TODO : data/ds9.physical.windows.reg contains different values -> Why? 'data/ds9.physical.reg', 'data/ds9.physical.strip.reg', ]) def test_file(filename): filename = get_pkg_data_filename(filename) regs = read_ds9(filename, errors='warn') coordsys = os.path.basename(filename).split(".")[1] actual = ds9_objects_to_string(regs, coordsys=str(coordsys), fmt='.2f', radunit=None if coordsys=='physical' else 'arcsec').strip() reffile = get_pkg_data_filename('data/{coordsys}{strip}_reference.reg' .format(coordsys=coordsys, strip=("_strip" if "strip" in filename else ""))) with open(reffile, 'r') as fh: desired = fh.read().strip() # since metadata is not required to preserve order, we have to do a more # complex comparison desired_lines = [set(line.split(" ")) for line in desired.split("\n")] actual_lines = [set(line.split(" ")) for line in actual.split("\n")] for split_line in actual_lines: assert split_line in desired_lines for split_line in desired_lines: assert split_line in actual_lines def test_ds9_objects_to_str(): """ Simple test case for ds9_objects_to_str. """ center = SkyCoord(42, 43, unit='deg') radius = Angle(3, 'deg') region = CircleSkyRegion(center, radius) expected = '# Region file format: DS9 astropy/regions\nfk5\ncircle(42.0000,43.0000,3.0000)\n' actual = ds9_objects_to_string([region], fmt='.4f') assert actual == expected def test_ds9_string_to_objects(): """ Simple test case for ds9_string_to_objects. """ ds9_str = '# Region file format: DS9 astropy/regions\nfk5\ncircle(42.0000,43.0000,3.0000)\n' parser = DS9Parser(ds9_str) regions = parser.shapes.to_regions() reg = regions[0] assert_allclose(reg.center.ra.deg, 42) assert_allclose(reg.center.dec.deg, 43) assert_allclose(reg.radius.value, 3) def test_ds9_string_to_objects_whitespace(): """ Simple test case for ds9_string_to_objects. """ ds9_str = '# Region file format: DS9 astropy/regions\nfk5\n -circle(42.0000,43.0000,3.0000)\n' parser = DS9Parser(ds9_str) assert parser.shapes[0].include == False def test_ds9_io(tmpdir): """ Simple test case for write_ds9 and read_ds9. """ center = SkyCoord(42, 43, unit='deg', frame='fk5') radius = Angle(3, 'deg') reg = CircleSkyRegion(center, radius) reg.meta['name'] = 'MyName' filename = os.path.join(str(tmpdir), 'ds9.reg') write_ds9([reg], filename, coordsys='fk5') reg = read_ds9(filename)[0] assert_allclose(reg.center.ra.deg, 42) assert_allclose(reg.center.dec.deg, 43) assert_allclose(reg.radius.value, 3) assert 'name' in reg.meta assert reg.meta['name'] == 'MyName' def test_missing_region_warns(): ds9_str = '# Region file format: DS9 astropy/regions\nfk5\ncircle(42.0000,43.0000,3.0000)\nnotaregiontype(blah)' # this will warn on both the commented first line and the not_a_region line with catch_warnings(AstropyUserWarning) as ASWarn: parser = DS9Parser(ds9_str, errors='warn') assert len(parser.shapes) == 1 assert len(ASWarn) == 1 assert "Region type 'notaregiontype' was identified, but it is not one of the known region types." in str(ASWarn[0].message) def test_global_parser(): """ Check that the global_parser does what's expected """ # have to force "str" here because unicode_literals makes this string a # unicode string, even though in python2.7 we don't want it to be. But in # py3, we don't want it to be bytes. global_test_str = str('global color=green dashlist=8 3 width=1' ' font="helvetica 10 normal roman" select=1' ' highlite=1 dash=0 fixed=0 edit=1 move=1' ' delete=1 include=1 source=1') global_parser = DS9Parser(global_test_str) assert dict(global_parser.global_meta) == {'dash': '0', 'source': '1', 'move': '1', 'font': 'helvetica 10 normal roman', 'dashlist': '8 3', 'include': True, 'highlite': '1', 'color': 'green', 'select': '1', 'fixed': '0', 'width': '1', 'edit': '1', 'delete': '1'} def test_ds9_color(): """ Color parsing test """ ds9_str = '# Region file format: DS9 astropy/regions\nfk5\ncircle(42.0000,43.0000,3.0000) # color=green' \ '\ncircle(43.0000,43.0000,3.0000) # color=orange\n' parser = DS9Parser(ds9_str) regions = parser.shapes assert regions[0].meta['color'] == 'green' assert regions[1].meta['color'] == 'orange' def test_ds9_color_override_global(): """ Color parsing test in the presence of a global """ global_test_str = str('global color=blue dashlist=8 3 width=1' ' font="helvetica 10 normal roman" select=1' ' highlite=1 dash=0 fixed=0 edit=1 move=1' ' delete=1 include=1 source=1') ds9_str = '# Region file format: DS9 astropy/regions\n{global_str}\nfk5\n' reg1str = "circle(42.0000,43.0000,3.0000) # color=green" reg2str = "circle(43.0000,43.0000,3.0000) # color=orange" reg3str = "circle(43.0000,43.0000,3.0000)" ds9_str = ds9_str.format(global_str=global_test_str) + "\n".join([reg1str, reg2str, reg3str]) parser = DS9Parser(ds9_str) regions = parser.shapes assert regions[0].meta['color'] == 'green' assert regions[1].meta['color'] == 'orange' assert regions[2].meta['color'] == 'blue' def test_issue134_regression(): regstr = 'galactic; circle(+0:14:26.064,+0:00:45.206,30.400")' parser = DS9Parser(regstr) regions = parser.shapes assert regions[0].to_region().radius.value == 30.4 def test_issue65_regression(): regstr = 'J2000; circle 188.5557102 12.0314056 1" # color=red' parser = DS9Parser(regstr) regions = parser.shapes reg = regions[0].to_region() assert reg.center.ra.value == 188.5557102 assert reg.center.dec.value == 12.0314056 assert reg.radius.value == 1.0 def test_pixel_angle(): """ Checks whether angle in PixelRegions is a u.Quantity object. """ reg_str = 'image\nbox(1.5,2,2,1,0)' reg = DS9Parser(reg_str).shapes.to_regions()[0] assert isinstance(reg.angle, u.quantity.Quantity) def test_expicit_formatting_directives(): """ Checks whether every explicit formatting directive is supported """ reg_str = 'image\ncircle(1.5, 2, 2)' valid_coord = DS9Parser(reg_str).shapes[0].coord reg_str_explicit = 'image\ncircle(1.5p, 2p, 2p)' coord = DS9Parser(reg_str_explicit).shapes[0].coord assert_quantity_allclose(coord, valid_coord) reg_str_explicit = 'image\ncircle(1.5i, 2i, 2i)' coord = DS9Parser(reg_str_explicit).shapes[0].coord assert_quantity_allclose(coord, valid_coord) reg_str = 'fk5\ncircle(1.5, 2, 2)' valid_coord = DS9Parser(reg_str).shapes[0].coord reg_str_explicit = 'fk5\ncircle(1.5d, 2d, 2d)' coord = DS9Parser(reg_str_explicit).shapes[0].coord assert_quantity_allclose(coord, valid_coord) reg_str_explicit = 'fk5\ncircle(1.5r, 2r, 2r)' coord = DS9Parser(reg_str_explicit).shapes[0].coord for val in coord: assert val.unit == u.Unit('rad') reg_str = 'fk5\ncircle(1:20:30, 2:3:7, 2)' valid_coord = DS9Parser(reg_str).shapes[0].coord reg_str_explicit = 'fk5\ncircle(1h20m30s, 2d3m7s, 2d)' coord = DS9Parser(reg_str_explicit).shapes[0].coord assert_quantity_allclose(u.Quantity(coord), u.Quantity(valid_coord)) def test_text_metadata(): """ Regression test for issue #233: make sure that text metadata is parsed and stored appropriately. """ reg_str = 'image\ncircle(1.5, 2, 2) # text={this_is_text}' parsed_reg = DS9Parser(reg_str) assert len(parsed_reg.shapes) == 1 assert parsed_reg.shapes[0].meta['text'] == 'this_is_text' regs = parsed_reg.shapes.to_regions() assert regs[0].meta['label'] == 'this_is_text' assert regs[0].meta['text'] == 'this_is_text' regions-0.4/regions/io/ds9/write.py0000644000076600000240000000365113501414013017341 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals from ..core import to_shape_list __all__ = [ 'write_ds9', 'ds9_objects_to_string', ] def ds9_objects_to_string(regions, coordsys='fk5', fmt='.6f', radunit='deg'): """ Converts a `list` of `~regions.Region` to DS9 region string. See :ref:`gs-ds9` Parameters ---------- regions : `list` List of `~regions.Region` objects coordsys : `str`, optional This overrides the coordinate system frame for all regions. Default is 'fk5'. fmt : `str`, optional A python string format defining the output precision. Default is .6f, which is accurate to 0.0036 arcseconds. radunit : `str`, optional This denotes the unit of the radius. Default is 'deg'(degrees) Returns ------- region_string : `str` DS9 region string """ shapelist = to_shape_list(regions, coordsys) return shapelist.to_ds9(coordsys, fmt, radunit) def write_ds9(regions, filename, coordsys='fk5', fmt='.6f', radunit='deg'): """ Converts a `list` of `~regions.Region` to DS9 string and write to file. See :ref:`gs-ds9` Parameters ---------- regions : `list` List of `regions.Region` objects filename : `str` Filename in which the string is to be written. coordsys : `str`, optional #TODO Coordinate system that overrides the coordinate frames of all regions. Default is 'fk5'. fmt : `str`, optional A python string format defining the output precision. Default is .6f, which is accurate to 0.0036 arcseconds. radunit : `str`, optional This denotes the unit of the radius. Default is deg (degrees) """ output = ds9_objects_to_string(regions, coordsys, fmt, radunit) with open(filename, 'w') as fh: fh.write(output) regions-0.4/regions/io/fits/0000755000076600000240000000000013501657425016116 5ustar deilstaff00000000000000regions-0.4/regions/io/fits/__init__.py0000644000076600000240000000000013336761120020207 0ustar deilstaff00000000000000regions-0.4/regions/io/fits/core.py0000644000076600000240000000224313477731541017425 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function from astropy.utils.exceptions import AstropyUserWarning __all__ = [ 'FITSRegionParserWarning', 'FITSRegionParserError', ] class FITSRegionParserWarning(AstropyUserWarning): """ A generic warning class for FITS region parsing """ class FITSRegionParserError(ValueError): """ A generic error class for FITS region parsing """ language_spec = {'CIRCLE': ['X0', 'Y0', 'R0'], 'POINT': ['X0', 'Y0'], 'BOX': ['X0', 'Y0', 'R0', 'R1'], 'ANNULUS': ['X0', 'Y0', 'R0', 'R1'], 'ELLIPSE': ['X0', 'Y0', 'R0', 'R1', 'ROTANG0'], 'ELLIPTANNULUS': ['X0', 'Y0', 'R0', 'R1', 'R2', 'R3', 'ROTANG0'], 'ROTBOX': ['X0', 'Y0', 'R0', 'R1', 'ROTANG0'], 'RECTANGLE': ['X0', 'X1', 'Y0', 'Y1'], 'ROTRECTANGLE': ['X0', 'X1', 'Y0', 'Y1', 'ROTANG0'], 'POLYGON': ['X', 'Y'], 'PIE': ['X0', 'Y0', 'ROTANG0', 'ROTANG1'] } language_spec['SECTOR'] = language_spec['PIE'] regions-0.4/regions/io/fits/read.py0000644000076600000240000002066413501414013017373 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function from warnings import warn from astropy import units as u import numpy as np from astropy.table import Table from astropy.io import fits from astropy.wcs import WCS from .core import FITSRegionParserError, FITSRegionParserWarning, language_spec from ..core import Shape, ShapeList, reg_mapping __all__ = ['FITSRegionParser', 'read_fits_region', 'FITSRegionRowParser'] class FITSRegionParser(object): """ Parses a FITS Region table. Parameters ---------- table: `~astropy.table.Table` object A fits region table errors : ``warn``, ``ignore``, ``strict`` The error handling scheme to use for handling parsing errors. The default is 'strict', which will raise a `FITSRegionParserError`. `warn`` will raise a `FITSRegionParserWarning`, and ``ignore`` will do nothing (i.e., be silent). Examples -------- >>> from regions import FITSRegionParser >>> from astropy.table import Table >>> from astropy.utils.data import get_pkg_data_filename >>> filename = get_pkg_data_filename('data/fits_region.fits', ... package='regions.io.fits.tests') >>> table = Table.read(filename) >>> parser = FITSRegionParser(table) >>> shapes = parser.shapes >>> regions = shapes.to_regions() >>> regions[5] """ valid_columns = ['X', 'Y', 'SHAPE', 'COMPONENT', 'R', 'ROTANG'] def __init__(self, table, errors='strict'): if errors not in ('strict', 'ignore', 'warn'): msg = "``errors`` must be one of strict, ignore, or warn; is {}" raise ValueError(msg.format(errors)) if not isinstance(table, Table): raise TypeError("The table should be an astropy table object") self.table = table self.errors = errors self.unit = {} self._shapes = {} self.parse_table() @property def shapes(self): shape_list = ShapeList() components = list(self._shapes.keys()) components.sort() for component in components: shape_list += ShapeList(self._shapes[component]) return shape_list def _raise_error(self, msg): if self.errors == 'warn': warn(msg, FITSRegionParserWarning) elif self.errors == 'strict': raise FITSRegionParserError(msg) def parse_table(self): for col in self.table.colnames: if col not in self.valid_columns: self._raise_error("This table has an invalid column name: '{}'" .format(col)) else: self.unit[col] = self.table[col].unit if 'COMPONENT' not in self.table.colnames: self.table['COMPONENT'] = np.ones([1, len(self.table)]) for row in self.table: reg = FITSRegionRowParser(row, self.unit, self.errors) component, shape = reg.parse() if component in self.shapes: self._shapes[component].append(shape) else: self._shapes[component] = [shape] class FITSRegionRowParser(): """ Parses a single row of the FITS region table Parameters ---------- row: `~astropy.table.row.Row` object Single row of the region table that is to be parsed. unit: `dict` Units of each column in the row. errors : ``warn``, ``ignore``, ``strict`` The error handling scheme to use for handling parsing errors. The default is 'strict', which will raise a ``FITSRegionParserError``. `warn`` will raise a ``FITSRegionParserWarning``, and ``ignore`` will do nothing (i.e., be silent). """ def __init__(self, row, unit, errors='strict'): self.errors = errors self.unit = unit self.row = row region_type = self._get_col_value('SHAPE0', 'POINT')[0] # Default region is POINT if region_type == '': region_type = 'POINT' if region_type[0] == '!': self.include = False region_type = region_type[1:] else: self.include = True region_type = region_type.strip().upper() if region_type in language_spec: self.region_type = region_type else: self._raise_error("'{0}' is not a valid FITS Region type" .format(region_type)) self.component = str(self.row['COMPONENT']) def _get_col_value(self, colname, default=None): index = None if colname[-1].isdigit(): index = int(colname[-1]) colname = colname[: -1] try: val, unit = self.row[colname], self.unit[colname] if np.isscalar(val): val = np.array(val).reshape(1, ) if index is not None: if index < len(val) and val[index] is not None: return val[index], unit else: raise ValueError("The column: {0} must have more than {1} value for the " "region {2}".format(colname, index, self.region_type)) else: return val, unit except KeyError: if default is None: self._raise_error("The column: '{0}' is missing in the table" .format(colname)) else: return default def _raise_error(self, msg): if self.errors == 'warn': warn(msg, FITSRegionParserWarning) elif self.errors == 'strict': raise FITSRegionParserError(msg) def parse(self): coords = [] for x in language_spec[self.region_type]: y, unit = self._get_col_value(x) coords.append(self._parse_value(y, unit)) meta = {'tag': self.component} if self.region_type == 'POLYGON': coords_new = [] for x, y in zip(coords[0], coords[1]): coords_new += [x, y] coords = coords_new elif self.region_type == 'BOX': # Add a 0 rotation to turn it into ROTBOX coords.append(0.0*u.deg) region_type = self.region_type.lower() if region_type in reg_mapping['FITS_REGION']: region_type = reg_mapping['FITS_REGION'][region_type] else: self._raise_error("'{0}' is currently not supported in " "regions".format(self.region_type)) return self.component, Shape('physical', region_type, coords, meta, False, False) def _parse_value(self, val, unit): units = dict(pix=u.dimensionless_unscaled, deg=u.deg, rad=u.rad, ) if unit is not None: return val * units.get(str(unit), unit) else: self._raise_error("The unit: {} is invalid".format(unit)) def read_fits_region(filename, errors='strict'): """ Reads a FITS region file and scans for any fits regions table and converts them into `Region` objects. Parameters ---------- filename : str The file path errors : ``warn``, ``ignore``, ``strict`` The error handling scheme to use for handling parsing errors. The default is 'strict', which will raise a `FITSRegionParserError`. ``warn`` will raise a `FITSRegionParserWarning`, and ``ignore`` will do nothing (i.e., be silent). Returns ------- regions : list Python list of `regions.Region` objects. Examples -------- >>> from astropy.utils.data import get_pkg_data_filename >>> from regions import read_fits_region >>> file_read = get_pkg_data_filename('data/fits_region.fits', ... package='regions.io.fits.tests') >>> regions = read_fits_region(file_read) """ regions = [] with fits.open(filename) as hdul: for hdu in hdul: if hdu.name == 'REGION': table = Table.read(hdu) wcs = WCS(hdu.header, keysel=['image', 'binary', 'pixel']) regions_list = FITSRegionParser(table, errors).shapes.to_regions() # noqa for reg in regions_list: regions.append(reg.to_sky(wcs)) return regions regions-0.4/regions/io/fits/setup_package.py0000644000076600000240000000025613477731541021312 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst def get_package_data(): parser_test = ['data/*.fits'] return {'regions.io.fits.tests': parser_test} regions-0.4/regions/io/fits/tests/0000755000076600000240000000000013501657425017260 5ustar deilstaff00000000000000regions-0.4/regions/io/fits/tests/__init__.py0000644000076600000240000000000013336761120021351 0ustar deilstaff00000000000000regions-0.4/regions/io/fits/tests/data/0000755000076600000240000000000013501657425020171 5ustar deilstaff00000000000000regions-0.4/regions/io/fits/tests/data/fits_region.fits0000644000076600000240000003410013467310773023371 0ustar deilstaff00000000000000SIMPLE = T / conforms to FITS standard BITPIX = 8 / array data type NAXIS = 0 / number of array dimensions EXTEND = T END XTENSION= 'BINTABLE' / binary table extension BITPIX = 8 / array data type NAXIS = 2 / number of array dimensions NAXIS1 = 119 / length of dimension 1 NAXIS2 = 9 / length of dimension 2 PCOUNT = 0 / number of group parameters GCOUNT = 1 / number of groups TFIELDS = 6 / number of table fields EXTNAME = 'REGION ' EXTVER = 1 EXTLEVEL= 1 HDUNAME = 'REGION ' HDUCLASS= 'ASC ' HDUCLAS1= 'REGION ' HDUCLAS2= 'STANDARD' HDUVERS = '1.2.0 ' HDUDOC = 'ASC-FITS-REGION-1.2: Rots, McDowell: FITS REGION Binary Table Design'CONTENT = 'REGION ' TELESCOP= 'CHANDRA ' DATAMODE= 'FAINT ' INSTRUME= 'ACIS ' OBJECT = 'M101 ' ONTIME = 99514.55727793276 DEADC = 0.98733741 DEADAPP = F EXPOSURE= 98254.44528487051 LIVETIME= 98254.44528487051 DATE-OBS= '2000-03-26T00:20:55' DATE-END= '2000-03-27T04:40:34' TSTART = 70418401.45661506 TSTOP = 70518359.85670815 TELAPSE = 99958.40009309351 MJD-OBS = 51629.02779463675 MJDREF = 50814.0 TIMEREF = 'LOCAL ' TIMESYS = 'TT ' TIMEUNIT= 's ' EQUINOX = 2000.0 RADECSYS= 'ICRS ' USER = 'pence ' FILIN001= 'acisf00934N002_evt2.fits' CREATOR = 'extractor v4.84' DATE = '2008-06-20T16:49:07' ORIGIN = 'NASA/GSFC' MTYPE1 = 'sky ' MFORM1 = 'x,y ' MTYPE2 = 'EQPOS ' MFORM2 = 'RA,DEC ' TCTYP1 = 'RA---TAN' TCRPX1 = 4096.5 TDRPX1 = 4096.5 TCRVL1 = 210.7801525309 TCDLT1 = -0.00013666666666667 TDDLT1 = -0.00013666666666667 TCTYP2 = 'DEC--TAN' TCRPX2 = 4096.5 TDRPX2 = 4096.5 TCRVL2 = 54.366791304488 TCDLT2 = 0.00013666666666667 TDDLT2 = 0.00013666666666667 TCROT2 = 0.0 CHECKSUM= 'ZmaGdkTDZkYDdkYD' DATASUM = '3203022982' TTYPE1 = 'X ' TFORM1 = '4D ' TUNIT1 = 'pix ' TTYPE2 = 'Y ' TFORM2 = '4D ' TUNIT2 = 'pix ' TTYPE3 = 'SHAPE ' TFORM3 = '7A ' TTYPE4 = 'R ' TFORM4 = '4D ' TUNIT4 = 'pix ' TTYPE5 = 'ROTANG ' TFORM5 = 'D ' TUNIT5 = 'deg ' TTYPE6 = 'COMPONENT' TFORM6 = 'K ' END @¦¡@³À€circle@wß‹¬q ³@´¢ Ùb·@²ö‘ä÷eþROTBOX@”]Ö»˜Çã@„xÁÝ!ê@ dx2: dx1, dx2 = dx2, dx1 t1 = np.arctan(self.height / tan_angle / self.width) t2 = t1 + np.pi * u.rad dy1 = 0.5 * self.height * cos_angle * np.sin(t1) + 0.5 * self.width * sin_angle * np.cos(t1) dy2 = 0.5 * self.height * cos_angle * np.sin(t2) + 0.5 * self.width * sin_angle * np.cos(t2) if dy1 > dy2: dy1, dy2 = dy2, dy1 xmin = self.center.x + dx1 xmax = self.center.x + dx2 ymin = self.center.y + dy1 ymax = self.center.y + dy2 return BoundingBox.from_float(xmin, xmax, ymin, ymax) def to_mask(self, mode='center', subpixels=5): # NOTE: assumes this class represents a single circle self._validate_mode(mode, subpixels) if mode == 'center': mode = 'subpixels' subpixels = 1 # Find bounding box and mask size bbox = self.bounding_box ny, nx = bbox.shape # Find position of pixel edges and recenter so that ellipse is at origin xmin = float(bbox.ixmin) - 0.5 - self.center.x xmax = float(bbox.ixmax) - 0.5 - self.center.x ymin = float(bbox.iymin) - 0.5 - self.center.y ymax = float(bbox.iymax) - 0.5 - self.center.y if mode == 'subpixels': use_exact = 0 else: use_exact = 1 fraction = elliptical_overlap_grid( xmin, xmax, ymin, ymax, nx, ny, 0.5 * self.width, 0.5 * self.height, self.angle.to(u.rad).value, use_exact, subpixels, ) return RegionMask(fraction, bbox=bbox) def as_artist(self, origin=(0, 0), **kwargs): """ Matplotlib patch object for this region (`matplotlib.patches.Ellipse`). Parameters ---------- origin : array_like, optional The ``(x, y)`` pixel position of the origin of the displayed image. Default is (0, 0). kwargs : `dict` All keywords that a `~matplotlib.patches.Ellipse` object accepts Returns ------- patch : `~matplotlib.patches.Ellipse` Matplotlib ellipse patch """ from matplotlib.patches import Ellipse xy = self.center.x - origin[0], self.center.y - origin[1] width = self.width height = self.height # From the docstring: MPL expects "rotation in degrees (anti-clockwise)" angle = self.angle.to('deg').value mpl_params = self.mpl_properties_default('patch') mpl_params.update(kwargs) return Ellipse(xy=xy, width=width, height=height, angle=angle, **mpl_params) def rotate(self, center, angle): """Make a rotated region. Rotates counter-clockwise for positive ``angle``. Parameters ---------- center : `PixCoord` Rotation center point angle : `~astropy.coordinates.Angle` Rotation angle Returns ------- region : `EllipsePixelRegion` Rotated region (an independent copy) """ center = self.center.rotate(center, angle) angle = self.angle + angle return self.copy(center=center, angle=angle) class EllipseSkyRegion(SkyRegion): """ An ellipse defined using sky coordinates. Parameters ---------- center : `~astropy.coordinates.SkyCoord` The position of the center of the ellipse. width : `~astropy.units.Quantity` The width of the ellipse (before rotation) as an angle height : `~astropy.units.Quantity` The height of the ellipse (before rotation) as an angle angle : `~astropy.units.Quantity`, optional The rotation angle of the ellipse, measured anti-clockwise. If set to zero (the default), the width axis is lined up with the longitude axis of the celestial coordinates. meta : `~regions.RegionMeta` object, optional A dictionary which stores the meta attributes of this region. visual : `~regions.RegionVisual` object, optional A dictionary which stores the visual meta attributes of this region. """ center = ScalarSky('center') width = QuantityLength('width') height = QuantityLength('height') angle = QuantityLength('angle') def __init__(self, center, width, height, angle=0. * u.deg, meta=None, visual=None): self.center = center self.width = width self.height = height self.angle = angle self.meta = meta or RegionMeta() self.visual = visual or RegionVisual() self._repr_params = ('width', 'height', 'angle') def to_pixel(self, wcs): center, scale, north_angle = skycoord_to_pixel_scale_angle(self.center, wcs) # FIXME: The following line is needed to get a scalar PixCoord center = PixCoord(float(center.x), float(center.y)) height = self.height.to('deg').value * scale width = self.width.to('deg').value * scale return EllipsePixelRegion(center, width, height, angle=self.angle + (north_angle - 90 * u.deg), meta=self.meta, visual=self.visual) regions-0.4/regions/shapes/line.py0000644000076600000240000001344713501650710017325 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import (absolute_import, division, print_function, unicode_literals) import numpy as np import astropy.units as u from astropy.wcs.utils import pixel_to_skycoord, skycoord_to_pixel from ..core import PixCoord, PixelRegion, SkyRegion, BoundingBox from ..core.attributes import ScalarPix, ScalarSky, RegionVisual, RegionMeta __all__ = ['LinePixelRegion', 'LineSkyRegion'] class LinePixelRegion(PixelRegion): """ A line in pixel coordinates. Parameters ---------- start : `~regions.PixCoord` Start position end : `~regions.PixCoord` End position meta : `~regions.RegionMeta` object, optional A dictionary which stores the meta attributes of this region. visual : `~regions.RegionVisual` object, optional A dictionary which stores the visual meta attributes of this region. Examples -------- .. plot:: :include-source: from regions import PixCoord, LinePixelRegion import matplotlib.pyplot as plt x1, y1 = 15, 10 x2, y2 = 20, 25 fig, ax = plt.subplots(1, 1) start = PixCoord(x=x1, y=y1) end = PixCoord(x=x2, y=y2) reg = LinePixelRegion(start=start, end=end) patch = reg.as_artist(facecolor='none', edgecolor='red', lw=2) ax.add_patch(patch) plt.xlim(0, 30) plt.ylim(0, 30) ax.set_aspect('equal') """ start = ScalarPix('start') end = ScalarPix('end') def __init__(self, start, end, meta=None, visual=None): self.start = start self.end = end self.meta = meta or RegionMeta() self.visual = visual or RegionVisual() self._repr_params = ('start', 'end') @property def area(self): """Region area (float).""" return 0 * u.sr def contains(self, pixcoord): if pixcoord.isscalar: in_reg = False else: in_reg = np.zeros(pixcoord.x.shape, dtype=bool) if self.meta.get('include', True): return in_reg else: return np.logical_not(in_reg) def to_sky(self, wcs, mode='local', tolerance=None): start = pixel_to_skycoord(self.start.x, self.start.y, wcs) end = pixel_to_skycoord(self.end.x, self.end.y, wcs) return LineSkyRegion(start, end) @property def bounding_box(self): """Bounding box (`~regions.BoundingBox`).""" xmin = min(self.start.x, self.end.x) xmax = max(self.start.x, self.end.x) ymin = min(self.start.y, self.end.y) ymax = max(self.start.y, self.end.y) return BoundingBox.from_float(xmin, xmax, ymin, ymax) def to_mask(self, mode='center', subpixels=5): # TODO: needs to be implemented raise NotImplementedError def as_artist(self, origin=(0, 0), **kwargs): """ Matplotlib patch object for this region (`matplotlib.patches.Arrow`). Parameters ---------- origin : array_like, optional The ``(x, y)`` pixel position of the origin of the displayed image. Default is (0, 0). kwargs : `dict` All keywords that a `~matplotlib.patches.Arrow` object accepts Returns ------- patch : `~matplotlib.patches.Arrow` Matplotlib line patch """ # Long term we want to support DS9 lines with arrow heads # We may want to use Line2D instead of arrow for lines because the width # of the arrow is non-scalable in patches from matplotlib.patches import Arrow x = self.start.x - origin[0] y = self.start.y - origin[1] dx = self.end.x - self.start.x dy = self.end.y - self.start.y if not 'width' in kwargs: kwargs['width'] = .1 # Let the default width be .1 instead of 1. mpl_params = self.mpl_properties_default('patch') mpl_params.update(kwargs) return Arrow(x, y, dx, dy, **mpl_params) def rotate(self, center, angle): """Make a rotated region. Rotates counter-clockwise for positive ``angle``. Parameters ---------- center : `PixCoord` Rotation center point angle : `~astropy.coordinates.Angle` Rotation angle Returns ------- region : `LinePixelRegion` Rotated region (an independent copy) """ start = self.start.rotate(center, angle) end = self.end.rotate(center, angle) return self.copy(start=start, end=end) class LineSkyRegion(SkyRegion): """ A line in sky coordinates. Parameters ---------- start : `~astropy.coordinates.SkyCoord` Start position end : `~astropy.coordinates.SkyCoord` End position meta : `~regions.RegionMeta` object, optional A dictionary which stores the meta attributes of this region. visual : `~regions.RegionVisual` object, optional A dictionary which stores the visual meta attributes of this region. """ start = ScalarSky('start') end = ScalarSky('end') def __init__(self, start, end, meta=None, visual=None): self.start = start self.end = end self.meta = meta or RegionMeta() self.visual = visual or RegionVisual() self._repr_params = ('start', 'end') def contains(self, skycoord, wcs): if self.meta.get('include', True): # lines never contain anything return False else: return True def to_pixel(self, wcs): start_x, start_y = skycoord_to_pixel(self.start, wcs=wcs) start = PixCoord(start_x, start_y) end_x, end_y = skycoord_to_pixel(self.end, wcs=wcs) end = PixCoord(end_x, end_y) return LinePixelRegion(start, end) regions-0.4/regions/shapes/point.py0000644000076600000240000001221313501650710017515 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from astropy.wcs.utils import pixel_to_skycoord, skycoord_to_pixel from ..core import PixCoord, PixelRegion, SkyRegion, BoundingBox from ..core.attributes import ScalarPix, ScalarSky, RegionMeta, RegionVisual __all__ = ['PointPixelRegion', 'PointSkyRegion'] class PointPixelRegion(PixelRegion): """ A point position in pixel coordinates. Parameters ---------- center : `~regions.PixCoord` The position of the point meta : `~regions.RegionMeta` object, optional A dictionary which stores the meta attributes of this region. visual : `~regions.RegionVisual` object, optional A dictionary which stores the visual meta attributes of this region. Examples -------- .. plot:: :include-source: from regions import PixCoord, PointPixelRegion, RegionVisual import matplotlib.pyplot as plt fig, ax = plt.subplots(1, 1) regs = [] regs.append(PointPixelRegion(PixCoord(2, 2), visual=RegionVisual(symbol='D'))) regs.append(PointPixelRegion(PixCoord(2, 3), visual=RegionVisual(symbol='*'))) regs.append(PointPixelRegion(PixCoord(3, 3), visual=RegionVisual(symbol='^'))) regs.append(PointPixelRegion(PixCoord(3, 2), visual=RegionVisual(symbol='*'))) regs.append(PointPixelRegion(PixCoord(2, 4), visual=RegionVisual(symbol='x'))) regs.append(PointPixelRegion(PixCoord(4, 2))) for reg in regs: reg.plot(ax=ax) plt.xlim(0, 6) plt.ylim(0, 6) ax.set_aspect('equal') """ center = ScalarPix('center') def __init__(self, center, meta=None, visual=None): self.center = center self.meta = meta or RegionMeta() self.visual = visual or RegionVisual() self._repr_params = tuple() @property def area(self): return 0 def contains(self, pixcoord): if pixcoord.isscalar: in_reg = False else: in_reg = np.zeros(pixcoord.x.shape, dtype=bool) if self.meta.get('include', True): # in_reg = False, always. Points do not include anything return in_reg else: return np.logical_not(in_reg) def to_sky(self, wcs): center = pixel_to_skycoord(self.center.x, self.center.y, wcs=wcs) return PointSkyRegion(center) @property def bounding_box(self): return BoundingBox.from_float(self.center.x, self.center.x, self.center.y, self.center.y) def to_mask(self, mode='center', subpixels=5): # TODO: needs to be implemented raise NotImplementedError def as_artist(self, origin=(0, 0), **kwargs): """ Matplotlib Line2D object for this region (`matplotlib.lines.Line2D`). Parameters ---------- origin : array_like, optional The ``(x, y)`` pixel position of the origin of the displayed image. Default is (0, 0). kwargs : `dict` All keywords that a `~matplotlib.lines.Line2D` object accepts Returns ------- point : `~matplotlib.lines.Line2D` Matplotlib Line2D object. """ from matplotlib.lines import Line2D mpl_params = self.mpl_properties_default('LINE2D') mpl_params.update(kwargs) point = Line2D([self.center.x - origin[0]], [self.center.y - origin[1]], **mpl_params) return point def rotate(self, center, angle): """Make a rotated region. Rotates counter-clockwise for positive ``angle``. Parameters ---------- center : `PixCoord` Rotation center point angle : `~astropy.coordinates.Angle` Rotation angle Returns ------- region : `PointPixelRegion` Rotated region (an independent copy) """ center = self.center.rotate(center, angle) return self.copy(center=center) class PointSkyRegion(SkyRegion): """ A pixel region in sky coordinates. Parameters ---------- center : `~astropy.coordinates.SkyCoord` The position of the point meta : `regions.RegionMeta` object, optional A dictionary which stores the meta attributes of this region. visual : `~regions.RegionVisual` object, optional A dictionary which stores the visual meta attributes of this region. """ center = ScalarSky('center') def __init__(self, center, meta=None, visual=None): self.center = center self.meta = meta or RegionMeta() self.visual = visual or RegionVisual() self._repr_params = tuple() def contains(self, skycoord, wcs): if self.meta.get('include', True): # points never include anything return False else: return True def to_pixel(self, wcs): center_x, center_y = skycoord_to_pixel(self.center, wcs=wcs) center = PixCoord(center_x, center_y) return PointPixelRegion(center) regions-0.4/regions/shapes/polygon.py0000644000076600000240000001404313501414017020054 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from astropy.wcs.utils import skycoord_to_pixel, pixel_to_skycoord from ..core import PixelRegion, SkyRegion, RegionMask, BoundingBox, PixCoord from .._geometry import polygonal_overlap_grid from .._geometry.pnpoly import points_in_polygon from ..core.attributes import OneDPix, OneDSky, RegionMeta, RegionVisual __all__ = ['PolygonPixelRegion', 'PolygonSkyRegion'] class PolygonPixelRegion(PixelRegion): """ A polygon in pixel coordinates. Parameters ---------- vertices : `~regions.PixCoord` The vertices of the polygon meta : `~regions.RegionMeta` object, optional A dictionary which stores the meta attributes of this region. visual : `~regions.RegionVisual` object, optional A dictionary which stores the visual meta attributes of this region. Examples -------- .. plot:: :include-source: import numpy as np from astropy.coordinates import Angle from regions import PixCoord, PolygonPixelRegion import matplotlib.pyplot as plt x, y = [45, 45, 55, 60], [75, 70, 65, 75] fig, ax = plt.subplots(1, 1) vertices = PixCoord(x=x, y=y) reg = PolygonPixelRegion(vertices=vertices) patch = reg.as_artist(facecolor='none', edgecolor='red', lw=2) ax.add_patch(patch) plt.xlim(30, 80) plt.ylim(50, 80) ax.set_aspect('equal') """ vertices = OneDPix('vertices') def __init__(self, vertices, meta=None, visual=None): self.vertices = vertices self.meta = meta or RegionMeta() self.visual = visual or RegionVisual() self._repr_params = ('vertices',) @property def area(self): """Region area (float).""" raise NotImplementedError def contains(self, pixcoord): pixcoord = PixCoord._validate(pixcoord, 'pixcoord') x = np.atleast_1d(np.asarray(pixcoord.x, dtype=float)) y = np.atleast_1d(np.asarray(pixcoord.y, dtype=float)) vx = np.asarray(self.vertices.x, dtype=float) vy = np.asarray(self.vertices.y, dtype=float) shape = x.shape mask = points_in_polygon(x.flatten(), y.flatten(), vx, vy).astype(bool) in_poly = mask.reshape(shape) if self.meta.get('include', True): return in_poly else: return np.logical_not(in_poly) def to_sky(self, wcs): vertices_sky = pixel_to_skycoord(self.vertices.x, self.vertices.y, wcs) return PolygonSkyRegion(vertices=vertices_sky) @property def bounding_box(self): xmin = self.vertices.x.min() xmax = self.vertices.x.max() ymin = self.vertices.y.min() ymax = self.vertices.y.max() return BoundingBox.from_float(xmin, xmax, ymin, ymax) def to_mask(self, mode='center', subpixels=5): self._validate_mode(mode, subpixels) if mode == 'center': mode = 'subpixels' subpixels = 1 if mode == 'subpixels': use_exact = 0 else: use_exact = 1 # Find bounding box and mask size bbox = self.bounding_box ny, nx = bbox.shape # Find position of pixel edges and recenter so that circle is at origin xmin = float(bbox.ixmin) - 0.5 xmax = float(bbox.ixmax) - 0.5 ymin = float(bbox.iymin) - 0.5 ymax = float(bbox.iymax) - 0.5 vx = np.asarray(self.vertices.x, dtype=float) vy = np.asarray(self.vertices.y, dtype=float) fraction = polygonal_overlap_grid( xmin, xmax, ymin, ymax, nx, ny, vx, vy, use_exact, subpixels, ) return RegionMask(fraction, bbox=bbox) def as_artist(self, origin=(0, 0), **kwargs): """ Matplotlib patch object for this region (`matplotlib.patches.Polygon`). Parameters ---------- origin : array_like, optional The ``(x, y)`` pixel position of the origin of the displayed image. Default is (0, 0). kwargs : `dict` All keywords that a `~matplotlib.patches.Polygon` object accepts Returns ------- patch : `~matplotlib.patches.Polygon` Matplotlib polygon patch """ from matplotlib.patches import Polygon xy = np.vstack([self.vertices.x - origin[0], self.vertices.y - origin[1]]).transpose() mpl_params = self.mpl_properties_default('patch') mpl_params.update(kwargs) return Polygon(xy=xy, **mpl_params) def rotate(self, center, angle): """Make a rotated region. Rotates counter-clockwise for positive ``angle``. Parameters ---------- center : `PixCoord` Rotation center point angle : `~astropy.coordinates.Angle` Rotation angle Returns ------- region : `PolygonPixelRegion` Rotated region (an independent copy) """ vertices = self.vertices.rotate(center, angle) return self.copy(vertices=vertices) class PolygonSkyRegion(SkyRegion): """ A polygon defined using vertices in sky coordinates. Parameters ---------- vertices : `~astropy.coordinates.SkyCoord` The vertices of the polygon meta : `~regions.RegionMeta` object, optional A dictionary which stores the meta attributes of this region. visual : `~regions.RegionVisual` object, optional A dictionary which stores the visual meta attributes of this region. """ vertices = OneDSky('vertices') def __init__(self, vertices, meta=None, visual=None): self.vertices = vertices self.meta = meta or RegionMeta() self.visual = visual or RegionVisual() self._repr_params = ('vertices',) def to_pixel(self, wcs): x, y = skycoord_to_pixel(self.vertices, wcs) vertices_pix = PixCoord(x, y) return PolygonPixelRegion(vertices_pix) regions-0.4/regions/shapes/rectangle.py0000644000076600000240000002503613501414017020335 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from astropy import units as u from astropy.coordinates import Angle from astropy.wcs.utils import pixel_to_skycoord from ..core import PixCoord, PixelRegion, SkyRegion, RegionMask, BoundingBox from .._geometry import rectangular_overlap_grid from .._utils.wcs_helpers import skycoord_to_pixel_scale_angle from ..core.attributes import ScalarPix, ScalarLength, QuantityLength, ScalarSky from .polygon import PolygonPixelRegion __all__ = ['RectanglePixelRegion', 'RectangleSkyRegion'] class RectanglePixelRegion(PixelRegion): """ A rectangle in pixel coordinates. Parameters ---------- center : `~regions.PixCoord` The position of the center of the rectangle. width : `float` The width of the rectangle (before rotation) in pixels height : `float` The height of the rectangle (before rotation) in pixels angle : `~astropy.units.Quantity`, optional The rotation angle of the rectangle, measured anti-clockwise. If set to zero (the default), the width axis is lined up with the x axis. meta : `~regions.RegionMeta` object, optional A dictionary which stores the meta attributes of this region. visual : `~regions.RegionVisual` object, optional A dictionary which stores the visual meta attributes of this region. Examples -------- .. plot:: :include-source: import numpy as np from astropy.coordinates import Angle from regions import PixCoord, RectanglePixelRegion import matplotlib.pyplot as plt x, y = 15, 10 width, height = 8, 5 angle = Angle(30, 'deg') fig, ax = plt.subplots(1, 1) center = PixCoord(x=x, y=y) reg = RectanglePixelRegion(center=center, width=width, height=height, angle=angle) patch = reg.as_artist(facecolor='none', edgecolor='red', lw=2) ax.add_patch(patch) plt.xlim(0, 30) plt.ylim(0, 20) ax.set_aspect('equal') """ center = ScalarPix('center') width = ScalarLength('width') height = ScalarLength('height') angle = QuantityLength('angle') def __init__(self, center, width, height, angle=0 * u.deg, meta=None, visual=None): self.center = center self.width = width self.height = height self.angle = angle self.meta = meta or {} self.visual = visual or {} self._repr_params = ('width', 'height', 'angle') @property def area(self): """Region area (float)""" return self.width * self.height def contains(self, pixcoord): cos_angle = np.cos(self.angle) sin_angle = np.sin(self.angle) dx = pixcoord.x - self.center.x dy = pixcoord.y - self.center.y dx_rot = cos_angle * dx + sin_angle * dy dy_rot = sin_angle * dx - cos_angle * dy in_rect = (np.abs(dx_rot) < self.width * 0.5) & (np.abs(dy_rot) < self.height * 0.5) if self.meta.get('include', True): return in_rect else: return np.logical_not(in_rect) def to_sky(self, wcs): # TODO: write a pixel_to_skycoord_scale_angle center = pixel_to_skycoord(self.center.x, self.center.y, wcs) _, scale, north_angle = skycoord_to_pixel_scale_angle(center, wcs) width = Angle(self.width / scale, 'deg') height = Angle(self.height / scale, 'deg') return RectangleSkyRegion(center, width, height, angle=self.angle - (north_angle - 90 * u.deg), meta=self.meta, visual=self.visual) @property def bounding_box(self): """ The minimal bounding box (`~regions.BoundingBox`) enclosing the exact rectangular region. """ w2 = self.width / 2. h2 = self.height / 2. cos_angle = np.cos(self.angle) # self.angle is a Quantity sin_angle = np.sin(self.angle) # self.angle is a Quantity dx1 = abs(w2 * cos_angle - h2 * sin_angle) dy1 = abs(w2 * sin_angle + h2 * cos_angle) dx2 = abs(w2 * cos_angle + h2 * sin_angle) dy2 = abs(w2 * sin_angle - h2 * cos_angle) dx = max(dx1, dx2) dy = max(dy1, dy2) xmin = self.center.x - dx xmax = self.center.x + dx ymin = self.center.y - dy ymax = self.center.y + dy return BoundingBox.from_float(xmin, xmax, ymin, ymax) def to_mask(self, mode='center', subpixels=5): # NOTE: assumes this class represents a single circle self._validate_mode(mode, subpixels) if mode == 'center': mode = 'subpixels' subpixels = 1 # Find bounding box and mask size bbox = self.bounding_box ny, nx = bbox.shape # Find position of pixel edges and recenter so that circle is at origin xmin = float(bbox.ixmin) - 0.5 - self.center.x xmax = float(bbox.ixmax) - 0.5 - self.center.x ymin = float(bbox.iymin) - 0.5 - self.center.y ymax = float(bbox.iymax) - 0.5 - self.center.y if mode == 'subpixels': use_exact = 0 else: use_exact = 1 fraction = rectangular_overlap_grid( xmin, xmax, ymin, ymax, nx, ny, self.width, self.height, self.angle.to(u.rad).value, use_exact, subpixels, ) return RegionMask(fraction, bbox=bbox) def as_artist(self, origin=(0, 0), **kwargs): """ Matplotlib patch object for this region (`matplotlib.patches.Rectangle`). Parameters ---------- origin : array_like, optional The ``(x, y)`` pixel position of the origin of the displayed image. Default is (0, 0). kwargs : `dict` All keywords that a `~matplotlib.patches.Rectangle` object accepts Returns ------- patch : `~matplotlib.patches.Rectangle` Matplotlib circle patch """ from matplotlib.patches import Rectangle xy = self._lower_left_xy() xy = xy[0] - origin[0], xy[1] - origin[1] width = self.width height = self.height # From the docstring: MPL expects "rotation in degrees (anti-clockwise)" angle = self.angle.to('deg').value mpl_params = self.mpl_properties_default('patch') mpl_params.update(kwargs) return Rectangle(xy=xy, width=width, height=height, angle=angle, **mpl_params) @property def corners(self): """ Return the x, y coordinate pairs that define the corners """ corners = [(-self.width / 2, -self.height / 2), (self.width / 2, -self.height / 2), (self.width / 2, self.height / 2), (-self.width / 2, self.height / 2), ] rotmat = [[np.cos(self.angle), np.sin(self.angle)], [-np.sin(self.angle), np.cos(self.angle)]] return np.dot(corners, rotmat) + np.array([self.center.x, self.center.y]) def to_polygon(self): """ Return a 4-cornered polygon equivalent to this rectangle """ x, y = self.corners.T vertices = PixCoord(x=x, y=y) return PolygonPixelRegion(vertices=vertices, meta=self.meta, visual=self.visual) def _lower_left_xy(self): """ Compute lower left `xy` position. This is used for the conversion to matplotlib in ``as_artist`` Taken from http://photutils.readthedocs.io/en/latest/_modules/photutils/aperture/rectangle.html#RectangularAperture.plot """ hw = self.width / 2. hh = self.height / 2. sint = np.sin(self.angle) cost = np.cos(self.angle) dx = (hh * sint) - (hw * cost) dy = -(hh * cost) - (hw * sint) x = self.center.x + dx y = self.center.y + dy return x, y def rotate(self, center, angle): """Make a rotated region. Rotates counter-clockwise for positive ``angle``. Parameters ---------- center : `PixCoord` Rotation center point angle : `~astropy.coordinates.Angle` Rotation angle Returns ------- region : `RectanglePixelRegion` Rotated region (an independent copy) """ center = self.center.rotate(center, angle) angle = self.angle + angle return self.copy(center=center, angle=angle) class RectangleSkyRegion(SkyRegion): """ A rectangle in sky coordinates. Parameters ---------- center : `~astropy.coordinates.SkyCoord` The position of the center of the rectangle. width : `~astropy.units.Quantity` The width of the rectangle (before rotation) as an angle height : `~astropy.units.Quantity` The height of the rectangle (before rotation) as an angle angle : `~astropy.units.Quantity`, optional The rotation angle of the rectangle, measured anti-clockwise. If set to zero (the default), the width axis is lined up with the longitude axis of the celestial coordinates. meta : `~regions.RegionMeta` object, optional A dictionary which stores the meta attributes of this region. visual : `~regions.RegionVisual` object, optional A dictionary which stores the visual meta attributes of this region. """ center = ScalarSky('center') width = QuantityLength('width') height = QuantityLength('height') angle = QuantityLength('angle') def __init__(self, center, width, height, angle=0 * u.deg, meta=None, visual=None): self.center = center self.width = width self.height = height self.angle = angle self.meta = meta or {} self.visual = visual or {} self._repr_params = ('width', 'height', 'angle') def to_pixel(self, wcs): center, scale, north_angle = skycoord_to_pixel_scale_angle(self.center, wcs) # FIXME: The following line is needed to get a scalar PixCoord center = PixCoord(float(center.x), float(center.y)) width = self.width.to('deg').value * scale height = self.height.to('deg').value * scale return RectanglePixelRegion(center, width, height, angle=self.angle + (north_angle - 90 * u.deg), meta=self.meta, visual=self.visual) regions-0.4/regions/shapes/setup_package.py0000644000076600000240000000025113477731541021214 0ustar deilstaff00000000000000import os def get_package_data(): data = [os.path.join('data', '*.fits'), os.path.join('baseline', '*.fits')] return {'regions.shapes.tests': data} regions-0.4/regions/shapes/tests/0000755000076600000240000000000013501657425017167 5ustar deilstaff00000000000000regions-0.4/regions/shapes/tests/__init__.py0000644000076600000240000000000013336761120021260 0ustar deilstaff00000000000000regions-0.4/regions/shapes/tests/data/0000755000076600000240000000000013501657425020100 5ustar deilstaff00000000000000regions-0.4/regions/shapes/tests/data/example_header.fits0000644000076600000240000000550013336761120023724 0ustar deilstaff00000000000000SIMPLE = T / conforms to FITS standard BITPIX = 8 / array data type NAXIS = 0 / number of array dimensions WCSAXES = 2 / Number of coordinate axes CRPIX1 = 100.5 / Pixel coordinate of reference point CRPIX2 = 100.5 / Pixel coordinate of reference point CDELT1 = -0.02 / [deg] Coordinate increment at reference point CDELT2 = 0.02 / [deg] Coordinate increment at reference point CUNIT1 = 'deg ' / Units of coordinate increment and value CUNIT2 = 'deg ' / Units of coordinate increment and value CTYPE1 = 'GLON-CAR' / galactic longitude, plate caree projection CTYPE2 = 'GLAT-CAR' / galactic latitude, plate caree projection CRVAL1 = 0 / [deg] Coordinate value at reference point CRVAL2 = 0 / [deg] Coordinate value at reference point LONPOLE = 0.0 / [deg] Native longitude of celestial pole LATPOLE = 90.0 / [deg] Native latitude of celestial pole BUNIT = '' END regions-0.4/regions/shapes/tests/reference/0000755000076600000240000000000013501657425021125 5ustar deilstaff00000000000000regions-0.4/regions/shapes/tests/reference/test_to_mask_circ-mode_center.txt0000644000076600000240000000133713336761120027642 0ustar deilstaff000000000000000.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_circ-mode_exact.txt0000644000076600000240000000133713336761120027466 0ustar deilstaff000000000000000.00000000e+00 1.12637824e-01 5.47795293e-01 6.97159714e-01 5.36338125e-01 9.98826171e-02 0.00000000e+00 1.41612171e-01 9.21332849e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 9.06385082e-01 1.20533937e-01 6.46660408e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 6.10634408e-01 8.43986340e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 8.07960340e-01 7.30305012e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 6.94279012e-01 2.73584439e-01 9.91864462e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 9.86382743e-01 2.43040158e-01 0.00000000e+00 3.04862210e-01 8.10551293e-01 9.59915714e-01 7.99094125e-01 2.82640956e-01 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_circ-mode_subpixels-subpixels_1.txt0000644000076600000240000000133713336761120032634 0ustar deilstaff000000000000000.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_circ-mode_subpixels-subpixels_18.txt0000644000076600000240000000133713336761120032724 0ustar deilstaff000000000000000.00000000e+00 1.11111111e-01 5.52469136e-01 7.00617284e-01 5.33950617e-01 9.87654321e-02 0.00000000e+00 1.41975309e-01 9.16666667e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 9.10493827e-01 1.20370370e-01 6.48148148e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 6.04938272e-01 8.30246914e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 8.17901235e-01 7.31481481e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 6.94444444e-01 2.71604938e-01 9.90740741e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 9.87654321e-01 2.40740741e-01 0.00000000e+00 3.02469136e-01 8.11728395e-01 9.47530864e-01 7.99382716e-01 2.83950617e-01 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_circ-mode_subpixels-subpixels_5.txt0000644000076600000240000000133713336761120032640 0ustar deilstaff000000000000000.00000000e+00 1.20000000e-01 5.20000000e-01 7.20000000e-01 5.20000000e-01 8.00000000e-02 0.00000000e+00 1.20000000e-01 9.20000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 8.80000000e-01 1.20000000e-01 6.40000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 6.00000000e-01 8.00000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 8.00000000e-01 7.20000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 7.20000000e-01 2.80000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 2.40000000e-01 0.00000000e+00 3.20000000e-01 8.00000000e-01 1.00000000e+00 8.00000000e-01 2.80000000e-01 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_elli-mode_center.txt0000644000076600000240000000245013336761120027644 0ustar deilstaff000000000000000.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_elli-mode_exact.txt0000644000076600000240000000245013336761120027470 0ustar deilstaff000000000000000.00000000e+00 8.01667043e-02 4.87639631e-01 7.30817612e-01 8.06746395e-01 7.45670005e-01 5.55430691e-01 2.27566801e-01 1.38968315e-04 0.00000000e+00 0.00000000e+00 1.41676247e-01 9.08318173e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 7.30547011e-01 1.05109527e-01 0.00000000e+00 5.95752634e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 8.66894487e-01 6.73606729e-02 6.00269727e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 4.91612660e-01 1.87245096e-01 9.74610937e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 6.06039373e-01 0.00000000e+00 2.94605839e-01 9.33077841e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 9.83823931e-01 2.40883497e-01 0.00000000e+00 0.00000000e+00 8.19102899e-02 5.04782713e-01 8.27328098e-01 9.90006863e-01 1.00000000e+00 9.74313237e-01 7.37734089e-01 2.41844795e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 2.28614469e-02 6.92455973e-02 1.36850721e-02 0.00000000e+00 0.00000000e+00 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_elli-mode_subpixels-subpixels_1.txt0000644000076600000240000000245013336761120032636 0ustar deilstaff000000000000000.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_elli-mode_subpixels-subpixels_18.txt0000644000076600000240000000245013336761120032726 0ustar deilstaff000000000000000.00000000e+00 8.33333333e-02 4.84567901e-01 7.31481481e-01 8.11728395e-01 7.43827160e-01 5.55555556e-01 2.25308642e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.41975309e-01 9.07407407e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 7.28395062e-01 1.01851852e-01 0.00000000e+00 5.95679012e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 8.61111111e-01 6.48148148e-02 6.01851852e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 4.90740741e-01 1.91358025e-01 9.75308642e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 5.95679012e-01 0.00000000e+00 2.96296296e-01 9.35185185e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 9.81481481e-01 2.43827160e-01 0.00000000e+00 0.00000000e+00 8.02469136e-02 5.03086420e-01 8.27160494e-01 9.90740741e-01 1.00000000e+00 9.72222222e-01 7.37654321e-01 2.37654321e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 2.46913580e-02 5.55555556e-02 1.54320988e-02 0.00000000e+00 0.00000000e+00 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_elli-mode_subpixels-subpixels_5.txt0000644000076600000240000000245013336761120032642 0ustar deilstaff000000000000000.00000000e+00 8.00000000e-02 4.80000000e-01 7.60000000e-01 8.00000000e-01 7.60000000e-01 5.60000000e-01 2.40000000e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.20000000e-01 8.80000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 7.20000000e-01 1.20000000e-01 0.00000000e+00 5.60000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 8.80000000e-01 8.00000000e-02 5.60000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 5.20000000e-01 2.00000000e-01 9.60000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 6.00000000e-01 0.00000000e+00 2.40000000e-01 9.60000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 2.40000000e-01 0.00000000e+00 0.00000000e+00 8.00000000e-02 5.20000000e-01 8.40000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 7.20000000e-01 2.00000000e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_poly-mode_center.txt0000644000076600000240000000133713336761120027705 0ustar deilstaff000000000000001.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_poly-mode_subpixels-subpixels_1.txt0000644000076600000240000000133713336761120032677 0ustar deilstaff000000000000001.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_poly-mode_subpixels-subpixels_18.txt0000644000076600000240000000133713336761120032767 0ustar deilstaff000000000000004.19753086e-01 3.98148148e-01 2.31481481e-01 6.17283951e-02 0.00000000e+00 0.00000000e+00 0.00000000e+00 6.04938272e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 8.88888889e-01 6.94444444e-01 1.85185185e-02 4.07407407e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 5.83333333e-01 0.00000000e+00 1.94444444e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 9.72222222e-01 1.11111111e-01 0.00000000e+00 2.16049383e-02 9.72222222e-01 1.00000000e+00 1.00000000e+00 6.01851852e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 3.91975309e-01 8.88888889e-01 9.81481481e-01 1.29629630e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 2.77777778e-02 2.56172840e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_poly-mode_subpixels-subpixels_5.txt0000644000076600000240000000133713336761120032703 0ustar deilstaff000000000000004.40000000e-01 4.00000000e-01 2.00000000e-01 4.00000000e-02 0.00000000e+00 0.00000000e+00 0.00000000e+00 6.00000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 8.80000000e-01 6.80000000e-01 0.00000000e+00 4.00000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 5.60000000e-01 0.00000000e+00 2.00000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 9.60000000e-01 8.00000000e-02 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 6.00000000e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 4.00000000e-01 9.20000000e-01 1.00000000e+00 1.60000000e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 4.00000000e-02 2.80000000e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_rect-mode_center.txt0000644000076600000240000000166113336761120027657 0ustar deilstaff000000000000000.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_rect-mode_subpixels-subpixels_1.txt0000644000076600000240000000166113336761120032651 0ustar deilstaff000000000000000.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_rect-mode_subpixels-subpixels_18.txt0000644000076600000240000000166113336761120032741 0ustar deilstaff000000000000000.00000000e+00 1.11111111e-01 3.08641975e-02 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 7.56172840e-01 9.78395062e-01 7.99382716e-01 5.83333333e-01 3.70370370e-01 1.57407407e-01 6.17283951e-03 0.00000000e+00 1.23456790e-02 9.59876543e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 9.38271605e-01 3.14814815e-01 1.82098765e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 2.00617284e-01 3.95061728e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 9.66049383e-01 2.16049383e-02 2.77777778e-02 2.16049383e-01 4.29012346e-01 6.41975309e-01 8.54938272e-01 9.96913580e-01 1.00000000e+00 7.77777778e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 7.09876543e-02 2.77777778e-01 2.77777778e-01 0.00000000e+00 regions-0.4/regions/shapes/tests/reference/test_to_mask_rect-mode_subpixels-subpixels_5.txt0000644000076600000240000000166113336761120032655 0ustar deilstaff000000000000000.00000000e+00 1.20000000e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 7.60000000e-01 1.00000000e+00 8.00000000e-01 5.60000000e-01 3.60000000e-01 1.60000000e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 9.60000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 9.60000000e-01 3.20000000e-01 1.60000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 2.00000000e-01 4.00000000e-01 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 1.00000000e+00 0.00000000e+00 0.00000000e+00 2.40000000e-01 4.40000000e-01 6.40000000e-01 8.40000000e-01 1.00000000e+00 1.00000000e+00 7.60000000e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00 8.00000000e-02 2.80000000e-01 2.40000000e-01 0.00000000e+00 regions-0.4/regions/shapes/tests/setup_package.py0000644000076600000240000000014013477731541022353 0ustar deilstaff00000000000000def get_package_data(): return {'regions.shapes.tests': ['reference/*.txt', 'data/*.fits']} regions-0.4/regions/shapes/tests/test_annulus.py0000644000076600000240000002530613501650710022261 0ustar deilstaff00000000000000from __future__ import print_function import numpy as np from numpy.testing import assert_allclose from astropy import units as u from astropy.coordinates import SkyCoord from astropy.tests.helper import assert_quantity_allclose from ...core import PixCoord from ...tests.helpers import make_simple_wcs from ..annulus import * from .test_common import BaseTestPixelRegion, BaseTestSkyRegion class TestCircleAnnulusPixelRegion(BaseTestPixelRegion): reg = CircleAnnulusPixelRegion(PixCoord(3, 4), inner_radius=2, outer_radius=3) sample_box = [0, 6, 1, 7] inside = [(3, 2)] outside = [(3, 0)] expected_area = 5 * np.pi expected_repr = '' expected_str = 'Region: CircleAnnulusPixelRegion\ncenter: PixCoord(x=3, y=4)\ninner radius: 2\nouter radius: 3' skycoord = SkyCoord(3 * u.deg, 4 * u.deg, frame='icrs') wcs = make_simple_wcs(skycoord, 5 * u.arcsec, 20) def test_init(self): assert_quantity_allclose(self.reg.center.x, 3) assert_quantity_allclose(self.reg.center.y, 4) assert_quantity_allclose(self.reg.inner_radius, 2) assert_quantity_allclose(self.reg.outer_radius, 3) def test_copy(self): reg = self.reg.copy() assert reg.center.xy == (3, 4) assert reg.inner_radius == 2 assert reg.outer_radius == 3 assert reg.visual == {} assert reg.meta == {} def test_transformation(self): skyannulus = self.reg.to_sky(wcs=self.wcs) assert isinstance(skyannulus, CircleAnnulusSkyRegion) def test_rotate(self): reg = self.reg.rotate(PixCoord(2, 3), 90 * u.deg) assert_allclose(reg.center.xy, (1, 4)) class TestCircleAnnulusSkyRegion(BaseTestSkyRegion): reg = CircleAnnulusSkyRegion(SkyCoord(3 * u.deg, 4 * u.deg), 20 * u.arcsec, 30 * u.arcsec) skycoord = SkyCoord(3 * u.deg, 4 * u.deg, frame='icrs') wcs = make_simple_wcs(skycoord, 5 * u.arcsec, 20) expected_repr = (', inner radius=20.0 arcsec, outer radius=30.0 arcsec)>') expected_str = ('Region: CircleAnnulusSkyRegion\ncenter: \ninner radius: 20.0 ' 'arcsec\nouter radius: 30.0 arcsec') def test_init(self): assert_quantity_allclose(self.reg.center.ra, self.skycoord.ra) assert_quantity_allclose(self.reg.inner_radius, 20 * u.arcsec) assert_quantity_allclose(self.reg.outer_radius, 30 * u.arcsec) def test_copy(self): reg = self.reg.copy() assert_allclose(reg.center.ra.deg, 3) assert_allclose(reg.inner_radius.to_value("arcsec"), 20) assert_allclose(reg.outer_radius.to_value("arcsec"), 30) assert reg.visual == {} assert reg.meta == {} def test_contains(self): assert not self.reg.contains(self.skycoord, self.wcs) test_coord = SkyCoord(3 * u.deg, 10 * u.deg, frame='icrs') assert not self.reg.contains(test_coord, self.wcs) def test_transformation(self): pixannulus = self.reg.to_pixel(wcs=self.wcs) assert isinstance(pixannulus, CircleAnnulusPixelRegion) class TestEllipseAnnulusPixelRegion(BaseTestPixelRegion): reg = EllipseAnnulusPixelRegion(PixCoord(3, 4), 2, 5, 5, 8) sample_box = [1, 6, 0, 9] inside = [(3, 7)] outside = [(3, 4)] expected_area = 7.5 * np.pi expected_repr = ('') expected_str = ('Region: EllipseAnnulusPixelRegion\ncenter: PixCoord(x=3, y=4)' '\ninner width: 2\ninner height: 5\nouter width: 5\n' 'outer height: 8\nangle: 0.0 deg') skycoord = SkyCoord(3 * u.deg, 4 * u.deg, frame='icrs') wcs = make_simple_wcs(skycoord, 5 * u.arcsec, 20) def test_init(self): assert_quantity_allclose(self.reg.center.x, 3) assert_quantity_allclose(self.reg.center.y, 4) assert_quantity_allclose(self.reg.inner_width, 2) assert_quantity_allclose(self.reg.inner_height, 5) assert_quantity_allclose(self.reg.outer_width, 5) assert_quantity_allclose(self.reg.outer_height, 8) def test_copy(self): reg = self.reg.copy() assert reg.center.xy == (3, 4) assert reg.inner_width == 2 assert reg.inner_height == 5 assert reg.outer_width == 5 assert reg.outer_height == 8 assert_allclose(reg.angle.to_value("deg"), 0) assert reg.visual == {} assert reg.meta == {} def test_transformation(self): skyannulus = self.reg.to_sky(wcs=self.wcs) assert isinstance(skyannulus, EllipseAnnulusSkyRegion) def test_rotate(self): reg = self.reg.rotate(PixCoord(2, 3), 90 * u.deg) assert_allclose(reg.center.xy, (1, 4)) assert_allclose(reg.angle.to_value("deg"), 90) class TestEllipseAnnulusSkyRegion(BaseTestSkyRegion): skycoord = SkyCoord(3 * u.deg, 4 * u.deg, frame='icrs') reg = EllipseAnnulusSkyRegion(skycoord, 20 * u.arcsec, 50 * u.arcsec, 50 * u.arcsec, 80 * u.arcsec) wcs = make_simple_wcs(skycoord, 5 * u.arcsec, 20) expected_repr = (', inner width=20.0 arcsec, ' 'inner height=50.0 arcsec, outer width=50.0 arcsec, ' 'outer height=80.0 arcsec, angle=0.0 deg)>') expected_str = ('Region: EllipseAnnulusSkyRegion\ncenter: \ninner width: 20.0 arcsec\n' 'inner height: 50.0 arcsec\nouter width: 50.0 arcsec\n' 'outer height: 80.0 arcsec\nangle: 0.0 deg') def test_init(self): assert_quantity_allclose(self.reg.center.ra, self.skycoord.ra) assert_quantity_allclose(self.reg.inner_width, 20 * u.arcsec) assert_quantity_allclose(self.reg.inner_height, 50 * u.arcsec) def test_copy(self): reg = self.reg.copy() assert_allclose(reg.center.ra.deg, 3) assert_allclose(reg.inner_width.to_value("arcsec"), 20) assert_allclose(reg.inner_height.to_value("arcsec"), 50) assert_allclose(reg.outer_width.to_value("arcsec"), 50) assert_allclose(reg.outer_height.to_value("arcsec"), 80) assert_allclose(reg.angle.to_value("deg"), 0) assert reg.visual == {} assert reg.meta == {} def test_contains(self): assert not self.reg.contains(self.skycoord, self.wcs) test_coord = SkyCoord(3 * u.deg, 10 * u.deg, frame='icrs') assert not self.reg.contains(test_coord, self.wcs) def test_transformation(self): pixannulus = self.reg.to_pixel(wcs=self.wcs) assert isinstance(pixannulus, EllipseAnnulusPixelRegion) class TestRectangleAnnulusPixelRegion(BaseTestPixelRegion): reg = RectangleAnnulusPixelRegion(PixCoord(3, 4), 2, 5, 5, 8) sample_box = [1, 6, 0, 9] inside = [(3, 7)] outside = [(3, 4)] expected_area = 30 expected_repr = ('') expected_str = ('Region: RectangleAnnulusPixelRegion\ncenter: PixCoord(x=3, y=4)' '\ninner width: 2\ninner height: 5\nouter width: 5\n' 'outer height: 8\nangle: 0.0 deg') skycoord = SkyCoord(3 * u.deg, 4 * u.deg, frame='icrs') wcs = make_simple_wcs(skycoord, 5 * u.arcsec, 20) def test_init(self): assert_quantity_allclose(self.reg.center.x, 3) assert_quantity_allclose(self.reg.center.y, 4) assert_quantity_allclose(self.reg.inner_width, 2) assert_quantity_allclose(self.reg.inner_height, 5) assert_quantity_allclose(self.reg.outer_width, 5) assert_quantity_allclose(self.reg.outer_height, 8) def test_copy(self): reg = self.reg.copy() assert_quantity_allclose(reg.center.x, 3) assert_quantity_allclose(reg.center.y, 4) assert_quantity_allclose(reg.inner_width, 2) assert_quantity_allclose(reg.inner_height, 5) assert_quantity_allclose(reg.outer_width, 5) assert_quantity_allclose(reg.outer_height, 8) def test_transformation(self): skyannulus = self.reg.to_sky(wcs=self.wcs) assert isinstance(skyannulus, RectangleAnnulusSkyRegion) def test_rotate(self): reg = self.reg.rotate(PixCoord(2, 3), 90 * u.deg) assert_allclose(reg.center.xy, (1, 4)) assert_allclose(reg.angle.to_value("deg"), 90) class TestRectangleAnnulusSkyRegion(BaseTestSkyRegion): skycoord = SkyCoord(3 * u.deg, 4 * u.deg, frame='icrs') reg = RectangleAnnulusSkyRegion(skycoord, 20 * u.arcsec, 50 * u.arcsec, 50 * u.arcsec, 80 * u.arcsec) wcs = make_simple_wcs(skycoord, 5 * u.arcsec, 20) expected_repr = (', inner width=20.0 arcsec, ' 'inner height=50.0 arcsec, outer width=50.0 arcsec, ' 'outer height=80.0 arcsec, angle=0.0 deg)>') expected_str = ('Region: RectangleAnnulusSkyRegion\ncenter: \ninner width: 20.0 arcsec\n' 'inner height: 50.0 arcsec\nouter width: 50.0 arcsec\n' 'outer height: 80.0 arcsec\nangle: 0.0 deg') def test_init(self): assert_quantity_allclose(self.reg.center.ra, self.skycoord.ra) assert_quantity_allclose(self.reg.inner_width, 20 * u.arcsec) assert_quantity_allclose(self.reg.inner_height, 50 * u.arcsec) def test_copy(self): reg = self.reg.copy() assert_allclose(reg.center.ra.deg, 3) assert_allclose(reg.inner_width.to_value("arcsec"), 20) assert_allclose(reg.inner_height.to_value("arcsec"), 50) assert_allclose(reg.outer_width.to_value("arcsec"), 50) assert_allclose(reg.outer_height.to_value("arcsec"), 80) assert_allclose(reg.angle.to_value("deg"), 0) assert reg.visual == {} assert reg.meta == {} def test_contains(self): assert not self.reg.contains(self.skycoord, self.wcs) test_coord = SkyCoord(3 * u.deg, 10 * u.deg, frame='icrs') assert not self.reg.contains(test_coord, self.wcs) def test_transformation(self): pixannulus = self.reg.to_pixel(wcs=self.wcs) assert isinstance(pixannulus, RectangleAnnulusPixelRegion) regions-0.4/regions/shapes/tests/test_api.py0000644000076600000240000001615513501640150021344 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ The tests in this file simply check what functionality is currently implemented and doesn't check anything about correctness. """ from __future__ import absolute_import, division, print_function, unicode_literals import itertools import pytest from astropy import units as u from astropy.coordinates import SkyCoord from astropy.wcs import WCS from ...core.mask import RegionMask from ...core.core import Region, SkyRegion, PixelRegion from ...core.pixcoord import PixCoord from ..circle import CirclePixelRegion, CircleSkyRegion from ..ellipse import EllipsePixelRegion, EllipseSkyRegion from ..polygon import PolygonPixelRegion, PolygonSkyRegion from ..rectangle import RectanglePixelRegion, RectangleSkyRegion from ..point import PointPixelRegion, PointSkyRegion from ..annulus import (CircleAnnulusPixelRegion, CircleAnnulusSkyRegion, RectangleAnnulusPixelRegion, RectangleAnnulusSkyRegion, EllipseAnnulusPixelRegion, EllipseAnnulusSkyRegion) PIXEL_REGIONS = [ CirclePixelRegion(PixCoord(3, 4), radius=5), CircleAnnulusPixelRegion(PixCoord(3, 4), 5, 7), EllipsePixelRegion(PixCoord(3, 4), width=7, height=5, angle=3 * u.deg), EllipseAnnulusPixelRegion(PixCoord(3, 4), 7, 9, 8, 10, angle=3 * u.deg), PolygonPixelRegion(PixCoord([1, 4, 3], [2, 4, 4])), RectanglePixelRegion(PixCoord(6, 5), width=3, height=5), RectangleAnnulusPixelRegion(PixCoord(6, 5), 3, 6, 5, 7), PointPixelRegion(PixCoord(1, 2)), ] SKY_REGIONS = [ CircleSkyRegion(SkyCoord(3 * u.deg, 4 * u.deg), radius=5 * u.deg), CircleAnnulusSkyRegion(SkyCoord(3 * u.deg, 4 * u.deg), 5 * u.deg, 7 * u.deg), EllipseSkyRegion(SkyCoord(3 * u.deg, 4 * u.deg), width=7 * u.deg, height=5 * u.deg, angle=3 * u.deg), EllipseAnnulusSkyRegion(SkyCoord(3 * u.deg, 4 * u.deg), 7 * u.deg, 9 * u.deg, 5 * u.deg, 9 * u.deg, angle=3 * u.deg), PolygonSkyRegion(SkyCoord([1, 4, 3] * u.deg, [2, 4, 4] * u.deg)), RectangleSkyRegion(SkyCoord(6 * u.deg, 5 * u.deg), width=3 * u.deg, height=5 * u.deg), RectangleAnnulusSkyRegion(SkyCoord(6 * u.deg, 5 * u.deg), 3 * u.deg, 5 * u.deg, 5 * u.deg, 7 * u.deg), PointSkyRegion(SkyCoord(6 * u.deg, 5 * u.deg)), ] MASK_MODES = ['center', 'exact', 'subpixels'] COMMON_WCS = WCS(naxis=2) COMMON_WCS.wcs.ctype = 'RA---TAN', 'DEC--TAN' def ids_func(arg): if isinstance(arg, Region): return arg.__class__.__name__ else: return str(arg) @pytest.mark.parametrize('region', PIXEL_REGIONS, ids=ids_func) def test_pix_in(region): PixCoord(1, 1) in region @pytest.mark.parametrize('region', PIXEL_REGIONS, ids=ids_func) def test_pix_area(region): # TODO: remove the pytest.skip once polygon area is implemented if isinstance(region, PolygonPixelRegion): pytest.skip() area = region.area assert not isinstance(area, u.Quantity) @pytest.mark.parametrize('region', PIXEL_REGIONS, ids=ids_func) def test_pix_to_sky(region): try: sky_region = region.to_sky(COMMON_WCS) assert isinstance(sky_region, SkyRegion) except NotImplementedError: pytest.xfail() @pytest.mark.parametrize(('region', 'mode'), itertools.product(PIXEL_REGIONS, MASK_MODES), ids=ids_func) def test_pix_to_mask(region, mode): try: mask = region.to_mask(mode=mode) assert isinstance(mask, RegionMask) except NotImplementedError: pytest.xfail() @pytest.mark.parametrize('region', SKY_REGIONS, ids=ids_func) def test_sky_in(region): region.contains(SkyCoord(1 * u.deg, 1 * u.deg, frame='icrs'), COMMON_WCS) @pytest.mark.parametrize('region', SKY_REGIONS, ids=ids_func) def test_sky_in_array(region): region.contains(SkyCoord([1, 2, 3] * u.deg, [3, 2, 1] * u.deg, frame='icrs'), COMMON_WCS) @pytest.mark.parametrize('region', SKY_REGIONS, ids=ids_func) def test_sky_to_pix(region): pix_region = region.to_pixel(wcs=COMMON_WCS) assert isinstance(pix_region, PixelRegion) @pytest.mark.parametrize('region', PIXEL_REGIONS, ids=ids_func) def test_attribute_validation_pixel_regions(region): invalid_values = dict(center=[PixCoord([1, 2], [2, 3]), 1, SkyCoord(1 * u.deg, 2 * u.deg)], radius=[u.Quantity("1deg"), [1], PixCoord(1, 2)], angle=[u.Quantity([1 * u.deg, 2 * u.deg]), 2, PixCoord(1, 2)], vertices=[u.Quantity("1"), 2, PixCoord(1, 2), PixCoord([[1, 2]], [[2, 3]])] ) invalid_values['width'] = invalid_values['radius'] invalid_values['height'] = invalid_values['radius'] invalid_values['inner_height'] = invalid_values['radius'] invalid_values['inner_width'] = invalid_values['radius'] invalid_values['outer_height'] = invalid_values['radius'] invalid_values['outer_width'] = invalid_values['radius'] invalid_values['inner_radius'] = invalid_values['radius'] invalid_values['outer_radius'] = invalid_values['radius'] invalid_values['start'] = invalid_values['center'] invalid_values['end'] = invalid_values['radius'] for attr in invalid_values: if hasattr(region, attr): for val in invalid_values.get(attr, None): with pytest.raises(ValueError) as err: setattr(region, attr, val) assert 'The {} must be'.format(attr) in str(err) @pytest.mark.parametrize('region', SKY_REGIONS, ids=ids_func) def test_attribute_validation_sky_regions(region): invalid_values = dict(center=[PixCoord([1, 2], [2, 3]), 1, SkyCoord([1 * u.deg], [2 * u.deg])], radius=[u.Quantity([1 * u.deg, 5 * u.deg]), [1], SkyCoord(1 * u.deg, 2 * u.deg), 1], angle=[u.Quantity([1 * u.deg, 2 * u.deg]), 2, SkyCoord(1 * u.deg, 2 * u.deg)], vertices=[u.Quantity("1deg"), 2, SkyCoord(1 * u.deg, 2 * u.deg), SkyCoord([[1 * u.deg, 2 * u.deg]], [[2 * u.deg, 3 * u.deg]])] ) invalid_values['width'] = invalid_values['radius'] invalid_values['height'] = invalid_values['radius'] invalid_values['inner_height'] = invalid_values['radius'] invalid_values['inner_width'] = invalid_values['radius'] invalid_values['outer_height'] = invalid_values['radius'] invalid_values['outer_width'] = invalid_values['radius'] invalid_values['inner_radius'] = invalid_values['radius'] invalid_values['outer_radius'] = invalid_values['radius'] invalid_values['start'] = invalid_values['center'] invalid_values['end'] = invalid_values['radius'] for attr in invalid_values: if hasattr(region, attr): for val in invalid_values.get(attr, None): with pytest.raises(ValueError) as err: setattr(region, attr, val) assert 'The {} must be'.format(attr) in str(err) regions-0.4/regions/shapes/tests/test_circle.py0000644000076600000240000000760613501414017022036 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from numpy.testing import assert_allclose import pytest from astropy import units as u from astropy.coordinates import SkyCoord from astropy.tests.helper import assert_quantity_allclose from astropy.utils.data import get_pkg_data_filename from astropy.io import fits from astropy.wcs import WCS from ...core import PixCoord from ...tests.helpers import make_simple_wcs from ..circle import CirclePixelRegion, CircleSkyRegion from .utils import HAS_MATPLOTLIB # noqa from .test_common import BaseTestPixelRegion, BaseTestSkyRegion @pytest.fixture(scope='session') def wcs(): filename = get_pkg_data_filename('data/example_header.fits') header = fits.getheader(filename) return WCS(header) class TestCirclePixelRegion(BaseTestPixelRegion): reg = CirclePixelRegion(PixCoord(3, 4), radius=2) sample_box = [0, 6, 1, 7] inside = [(3, 4)] outside = [(3, 0)] expected_area = 4 * np.pi expected_repr = '' expected_str = 'Region: CirclePixelRegion\ncenter: PixCoord(x=3, y=4)\nradius: 2' def test_copy(self): reg = self.reg.copy() assert reg.center.xy == (3, 4) assert reg.radius == 2 assert reg.visual == {} assert reg.meta == {} def test_pix_sky_roundtrip(self): wcs = make_simple_wcs(SkyCoord(2 * u.deg, 3 * u.deg), 0.1 * u.deg, 20) reg_new = self.reg.to_sky(wcs).to_pixel(wcs) assert_allclose(reg_new.center.x, self.reg.center.x) assert_allclose(reg_new.center.y, self.reg.center.y) assert_allclose(reg_new.radius, self.reg.radius) @pytest.mark.skipif('not HAS_MATPLOTLIB') def test_as_artist(self): patch = self.reg.as_artist() assert_allclose(patch.center, (3, 4)) assert_allclose(patch.radius, 2) def test_rotate(self): reg = self.reg.rotate(PixCoord(2, 3), 90 * u.deg) assert_allclose(reg.center.xy, (1, 4)) class TestCircleSkyRegion(BaseTestSkyRegion): reg = CircleSkyRegion(SkyCoord(3 * u.deg, 4 * u.deg), 2 * u.arcsec) expected_repr = (', radius=2.0 arcsec)>') expected_str = ('Region: CircleSkyRegion\ncenter: \nradius: 2.0 ' 'arcsec') def test_copy(self): reg = self.reg.copy() assert_allclose(reg.center.ra.deg, 3) assert_allclose(reg.radius.to_value("arcsec"), 2) assert reg.visual == {} assert reg.meta == {} def test_transformation(self, wcs): skycoord = SkyCoord(3 * u.deg, 4 * u.deg, frame='galactic') skycircle = CircleSkyRegion(skycoord, 2 * u.arcsec) pixcircle = skycircle.to_pixel(wcs) assert_allclose(pixcircle.center.x, -50.5) assert_allclose(pixcircle.center.y, 299.5) assert_allclose(pixcircle.radius, 0.027777777777828305) skycircle2 = pixcircle.to_sky(wcs) assert_quantity_allclose(skycircle.center.data.lon, skycircle2.center.data.lon) assert_quantity_allclose(skycircle.center.data.lat, skycircle2.center.data.lat) assert_quantity_allclose(skycircle2.radius, skycircle.radius) def test_dimension_center(self): center = SkyCoord([1, 2] * u.deg, [3, 4] * u.deg) radius = 2 * u.arcsec with pytest.raises(ValueError) as err: CircleSkyRegion(center, radius) assert 'The center must be a 0D SkyCoord object' in str(err) def test_contains(self, wcs): position = SkyCoord([1, 3] * u.deg, [2, 4] * u.deg) # 1,2 is outside, 3,4 is the center and is inside assert all(self.reg.contains(position, wcs) == np.array([False, True], dtype='bool')) regions-0.4/regions/shapes/tests/test_common.py0000644000076600000240000000477313477731541022107 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst # Base class for all shape tests from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from numpy.testing import assert_equal, assert_allclose import pytest from ..polygon import PolygonPixelRegion from ...core import PixCoord, BoundingBox class BaseTestRegion(object): def test_repr(self): assert repr(self.reg).replace(" ","") == self.expected_repr.replace(" ","") def test_str(self): assert str(self.reg).replace(" ","") == self.expected_str.replace(" ","") class BaseTestPixelRegion(BaseTestRegion): def test_area(self): # TODO: remove the pytest.skip once polygon area is implemented if isinstance(self.reg, PolygonPixelRegion): pytest.skip() assert_allclose(self.reg.area, self.expected_area) def test_mask_area(self): try: mask = self.reg.to_mask(mode='exact') assert_allclose(np.sum(mask.data), self.expected_area) except NotImplementedError: try: mask = self.reg.to_mask(mode='subpixels', subpixels=30) assert_allclose(np.sum(mask.data), self.expected_area, rtol=0.005) except NotImplementedError: pytest.skip() def test_contains_scalar(self): if len(self.inside) > 0: pixcoord = PixCoord(*self.inside[0]) assert self.reg.contains(pixcoord) assert pixcoord in self.reg if len(self.outside) > 0: pixcoord = PixCoord(*self.outside[0]) assert not self.reg.contains(pixcoord) assert pixcoord not in self.reg def test_contains_array_1d(self): pixcoord = PixCoord(*zip(*(self.inside + self.outside))) actual = self.reg.contains(pixcoord) assert_equal(actual[:len(self.inside)], True) assert_equal(actual[len(self.inside):], False) with pytest.raises(ValueError) as exc: pixcoord in self.reg assert 'coord must be scalar' in str(exc) def test_contains_array_2d(self): x, y = zip(*(self.inside + self.outside)) pixcoord = PixCoord([x] * 3, [y] * 3) actual = self.reg.contains(pixcoord) assert actual.shape == (3, len(x)) assert_equal(actual[:, :len(self.inside)], True) assert_equal(actual[:, len(self.inside):], False) class BaseTestSkyRegion(BaseTestRegion): # TODO: here we should add inside/outside tests as above pass regions-0.4/regions/shapes/tests/test_ellipse.py0000644000076600000240000001104313501414017022220 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from numpy.testing import assert_allclose import pytest import astropy.units as u from astropy.tests.helper import assert_quantity_allclose from astropy.coordinates import SkyCoord from astropy.utils.data import get_pkg_data_filename from astropy.io import fits from astropy.wcs import WCS from ...core import PixCoord from ...tests.helpers import make_simple_wcs from ..ellipse import EllipsePixelRegion, EllipseSkyRegion from .utils import HAS_MATPLOTLIB # noqa from .test_common import BaseTestPixelRegion, BaseTestSkyRegion @pytest.fixture(scope='session') def wcs(): filename = get_pkg_data_filename('data/example_header.fits') header = fits.getheader(filename) return WCS(header) class TestEllipsePixelRegion(BaseTestPixelRegion): reg = EllipsePixelRegion(center=PixCoord(3, 4), width=4, height=3, angle=5 * u.deg) sample_box = [-2, 8, -1, 9] inside = [(4.5, 4)] outside = [(5, 4)] expected_area = 3 * np.pi expected_repr = '' expected_str = ('Region: EllipsePixelRegion\ncenter: PixCoord(x=3, y=4)\n' 'width: 4\nheight: 3\nangle: 5.0 deg') def test_copy(self): reg = self.reg.copy() assert reg.center.xy == (3, 4) assert reg.width == 4 assert reg.height == 3 assert_allclose(reg.angle.to_value("deg"), 5) assert reg.visual == {} assert reg.meta == {} def test_pix_sky_roundtrip(self): wcs = make_simple_wcs(SkyCoord(2 * u.deg, 3 * u.deg), 0.1 * u.deg, 20) reg_new = self.reg.to_sky(wcs).to_pixel(wcs) assert_allclose(reg_new.center.x, self.reg.center.x) assert_allclose(reg_new.center.y, self.reg.center.y) assert_allclose(reg_new.width, self.reg.width) assert_allclose(reg_new.height, self.reg.height) assert_quantity_allclose(reg_new.angle, self.reg.angle) @pytest.mark.skipif('not HAS_MATPLOTLIB') def test_as_artist(self): patch = self.reg.as_artist() assert_allclose(patch.center, (3, 4)) assert_allclose(patch.width, 4) assert_allclose(patch.height, 3) assert_allclose(patch.angle, 5) def test_region_bbox(self): a = 7 b = 3 reg = EllipsePixelRegion(PixCoord(50, 50), width=a, height=b, angle=0. * u.deg) assert reg.bounding_box.shape == (b, a) reg = EllipsePixelRegion(PixCoord(50.5, 50.5), width=a, height=b, angle=0. * u.deg) assert reg.bounding_box.shape == (b + 1, a + 1) reg = EllipsePixelRegion(PixCoord(50, 50), width=a, height=b, angle=90. * u.deg) assert reg.bounding_box.shape == (a, b) def test_rotate(self): reg = self.reg.rotate(PixCoord(2, 3), 90 * u.deg) assert_allclose(reg.center.xy, (1, 4)) assert_allclose(reg.angle.to_value("deg"), 95) class TestEllipseSkyRegion(BaseTestSkyRegion): reg = EllipseSkyRegion( center=SkyCoord(3, 4, unit='deg'), width=4 * u.deg, height=3 * u.deg, angle=5 * u.deg, ) expected_repr = (', width=4.0 deg, height=3.0 deg,' ' angle=5.0 deg)>') expected_str = ('Region: EllipseSkyRegion\ncenter: \nwidth: 4.0 deg\n' 'height: 3.0 deg\nangle: 5.0 deg') def test_copy(self): reg = self.reg.copy() assert_allclose(reg.center.ra.deg, 3) assert_allclose(reg.width.to_value("deg"), 4) assert_allclose(reg.height.to_value("deg"), 3) assert_allclose(reg.angle.to_value("deg"), 5) assert reg.visual == {} assert reg.meta == {} def test_dimension_center(self): center = SkyCoord([1, 2] * u.deg, [3, 4] * u.deg) width = 2 * u.arcsec height = 3 * u.arcsec with pytest.raises(ValueError) as err: EllipseSkyRegion(center, width, height) assert 'The center must be a 0D SkyCoord object' in str(err) def test_contains(self, wcs): position = SkyCoord([1, 3] * u.deg, [2, 4] * u.deg) # 1,2 is outside, 3,4 is the center and is inside assert all(self.reg.contains(position, wcs) == np.array([False, True], dtype='bool')) regions-0.4/regions/shapes/tests/test_line.py0000644000076600000240000000743613501650710021527 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals from numpy.testing import assert_allclose import numpy as np import pytest from astropy import units as u from astropy.coordinates import SkyCoord from astropy.tests.helper import assert_quantity_allclose from astropy.utils.data import get_pkg_data_filename from astropy.io import fits from astropy.wcs import WCS from ...tests.helpers import make_simple_wcs from ...core import PixCoord from ..line import LinePixelRegion, LineSkyRegion from .utils import HAS_MATPLOTLIB # noqa from .test_common import BaseTestPixelRegion, BaseTestSkyRegion @pytest.fixture(scope='session') def wcs(): filename = get_pkg_data_filename('data/example_header.fits') header = fits.getheader(filename) return WCS(header) class TestLinePixelRegion(BaseTestPixelRegion): reg = LinePixelRegion(PixCoord(3, 4), PixCoord(4, 4)) sample_box = [-2, 8, -1, 9] inside = [] outside = [(3.1, 4.2), (5, 4)] expected_area = 0 expected_repr = '' expected_str = 'Region: LinePixelRegion\nstart: PixCoord(x=3, y=4)\nend: PixCoord(x=4, y=4)' def test_copy(self): reg = self.reg.copy() assert reg.start.xy == (3, 4) assert reg.end.xy == (4, 4) assert reg.visual == {} assert reg.meta == {} def test_pix_sky_roundtrip(self): wcs = make_simple_wcs(SkyCoord(2 * u.deg, 3 * u.deg), 0.1 * u.deg, 20) reg_new = self.reg.to_sky(wcs).to_pixel(wcs) assert_allclose(reg_new.start.x, self.reg.start.x) assert_allclose(reg_new.start.y, self.reg.start.y) assert_allclose(reg_new.end.x, self.reg.end.x) assert_allclose(reg_new.end.y, self.reg.end.y) @pytest.mark.skipif('not HAS_MATPLOTLIB') def test_as_artist(self): patch = self.reg.as_artist() assert 'Arrow' in str(patch) def test_rotate(self): reg = self.reg.rotate(PixCoord(2, 3), 90 * u.deg) assert_allclose(reg.start.xy, (1, 4)) assert_allclose(reg.end.xy, (1, 5)) class TestLineSkyRegion(BaseTestSkyRegion): start = SkyCoord(3 * u.deg, 4 * u.deg, frame='galactic') end = SkyCoord(3 * u.deg, 5 * u.deg, frame='galactic') reg = LineSkyRegion(start, end) expected_repr = (', end=)>') expected_str = ('Region: LineSkyRegion\nstart: \nend: ') def test_copy(self): reg = self.reg.copy() assert_allclose(reg.start.b.deg, 4) assert_allclose(reg.end.b.deg, 5) assert reg.visual == {} assert reg.meta == {} def test_transformation(self, wcs): pixline = self.reg.to_pixel(wcs) assert_allclose(pixline.start.x, -50.5) assert_allclose(pixline.start.y, 299.5) assert_allclose(pixline.end.x, -50.5) assert_allclose(pixline.end.y, 349.5) skyline = pixline.to_sky(wcs) assert_quantity_allclose(skyline.start.data.lon, self.reg.start.data.lon) assert_quantity_allclose(skyline.start.data.lat, self.reg.start.data.lat) assert_quantity_allclose(skyline.end.data.lon, self.reg.end.data.lon) assert_quantity_allclose(skyline.end.data.lat, self.reg.end.data.lat) def test_contains(self, wcs): position = SkyCoord([1, 2] * u.deg, [3, 4] * u.deg) # lines do not contain things assert all(self.reg.contains(position, wcs) == np.array([False, False], dtype='bool')) regions-0.4/regions/shapes/tests/test_masks.py0000644000076600000240000000402013477731541021716 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ This file sets up detailed tests for computing masks with reference images. """ from __future__ import absolute_import, division, print_function, unicode_literals import itertools import pytest from astropy import units as u from ...core import PixCoord from ...shapes.circle import CirclePixelRegion from ...shapes.ellipse import EllipsePixelRegion from ...shapes.rectangle import RectanglePixelRegion from ...shapes.polygon import PolygonPixelRegion REGIONS = [ CirclePixelRegion(PixCoord(3.981987, 4.131378), radius=3.3411), EllipsePixelRegion(PixCoord(5.981987, 4.131378), width=10.4466, height=6.6822, angle=12 * u.deg), RectanglePixelRegion(PixCoord(5.981987, 4.131378), width=7.2233, height=4.3411, angle=12 * u.deg), PolygonPixelRegion(PixCoord([-2.334, 3.631, 1.122, -1.341], [-3.121, -2.118, 2.987, 1.759])), ] MODES = [ {'mode': 'center'}, {'mode': 'exact'}, {'mode': 'subpixels', 'subpixels': 1}, {'mode': 'subpixels', 'subpixels': 5}, {'mode': 'subpixels', 'subpixels': 18}, ] def label(value): if isinstance(value, CirclePixelRegion): return 'circ' elif isinstance(value, EllipsePixelRegion): return 'elli' elif isinstance(value, RectanglePixelRegion): return 'rect' elif isinstance(value, PolygonPixelRegion): return 'poly' else: return '-'.join('{0}_{1}'.format(key, value) for key, value in sorted(value.items())) # There's a bug in numpy: `numpy.savetxt` doesn't accept unicode # on Python 2. Bytes works on Python 2 and 3, so we're using that here. # https://github.com/numpy/numpy/pull/4053#issuecomment-263808221 @pytest.mark.array_compare( fmt='text', write_kwargs={'fmt': b'%12.8e'}, ) @pytest.mark.parametrize( ('region', 'mode'), itertools.product(REGIONS, MODES), ids=label, ) def test_to_mask(region, mode): try: mask = region.to_mask(**mode) except NotImplementedError: pytest.xfail() return mask.data.astype(float) regions-0.4/regions/shapes/tests/test_point.py0000644000076600000240000000525713501650710021730 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from numpy.testing import assert_allclose import pytest from astropy import units as u from astropy.coordinates import SkyCoord from astropy.utils.data import get_pkg_data_filename from astropy.io import fits from astropy.wcs import WCS from ...core import PixCoord from ...tests.helpers import make_simple_wcs from ..point import PointPixelRegion, PointSkyRegion from .utils import HAS_MATPLOTLIB # noqa from .test_common import BaseTestPixelRegion, BaseTestSkyRegion @pytest.fixture(scope='session') def wcs(): filename = get_pkg_data_filename('data/example_header.fits') header = fits.getheader(filename) return WCS(header) class TestPointPixelRegion(BaseTestPixelRegion): reg = PointPixelRegion(PixCoord(3, 4)) sample_box = [-2, 8, -1, 9] inside = [] outside = [(3.1, 4.2), (5, 4)] expected_area = 0 expected_repr = '' expected_str = 'Region: PointPixelRegion\ncenter: PixCoord(x=3, y=4)' def test_copy(self): reg = self.reg.copy() assert reg.center.xy == (3, 4) assert reg.visual == {} assert reg.meta == {} def test_pix_sky_roundtrip(self): wcs = make_simple_wcs(SkyCoord(2 * u.deg, 3 * u.deg), 0.1 * u.deg, 20) reg_new = self.reg.to_sky(wcs).to_pixel(wcs) assert_allclose(reg_new.center.x, self.reg.center.x) assert_allclose(reg_new.center.y, self.reg.center.y) @pytest.mark.skipif('not HAS_MATPLOTLIB') def test_as_artist(self): artist = self.reg.as_artist() assert artist.get_data() == ([3], [4]) artist = self.reg.as_artist(origin=(1, 1)) assert artist.get_data() == ([2], [3]) def test_rotate(self): reg = self.reg.rotate(PixCoord(2, 3), 90 * u.deg) assert_allclose(reg.center.xy, (1, 4)) class TestPointSkyRegion(BaseTestSkyRegion): reg = PointSkyRegion(SkyCoord(3, 4, unit='deg')) expected_repr = (')>') expected_str = ('Region: PointSkyRegion\ncenter: ') def test_copy(self): reg = self.reg.copy() assert_allclose(reg.center.ra.deg, 3) assert reg.visual == {} assert reg.meta == {} def test_contains(self, wcs): position = SkyCoord([1, 2] * u.deg, [3, 4] * u.deg) # points do not contain things assert all(self.reg.contains(position, wcs) == np.array([False,False], dtype='bool')) regions-0.4/regions/shapes/tests/test_polygon.py0000644000076600000240000001262113501414017022255 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from numpy.testing import assert_allclose import pytest from astropy.tests.helper import assert_quantity_allclose from astropy import units as u from astropy.coordinates import SkyCoord from ..._utils.examples import make_example_dataset from ...core import PixCoord, BoundingBox from ...tests.helpers import make_simple_wcs from ..polygon import PolygonPixelRegion, PolygonSkyRegion from .utils import HAS_MATPLOTLIB # noqa from .test_common import BaseTestPixelRegion, BaseTestSkyRegion @pytest.fixture(scope='session') def wcs(): config = dict(crpix=(18, 9), cdelt=(-10, 10), shape=(18, 36)) dataset = make_example_dataset(config=config) return dataset.wcs class TestPolygonPixelRegion(BaseTestPixelRegion): reg = PolygonPixelRegion(PixCoord([1, 3, 1], [1, 1, 4])) sample_box = [0, 4, 0, 5] inside = [(2, 2)] outside = [(3, 2), (3, 3)] expected_area = 3 expected_repr = '' expected_str = ('Region: PolygonPixelRegion\nvertices: PixCoord(x=[1 3 1],' ' y=[1 1 4])') # We will be using this polygon for basic tests: # # (3,0) * # |\ # | \ # | \ # (0,0) *---* (2, 0) # def test_copy(self): reg = self.reg.copy() assert_allclose(reg.vertices.x, [1, 3, 1]) assert_allclose(reg.vertices.y, [1, 1, 4]) assert reg.visual == {} assert reg.meta == {} def test_pix_sky_roundtrip(self): wcs = make_simple_wcs(SkyCoord(2 * u.deg, 3 * u.deg), 0.1 * u.deg, 20) reg_new = self.reg.to_sky(wcs).to_pixel(wcs) assert_allclose(reg_new.vertices.x, self.reg.vertices.x) assert_allclose(reg_new.vertices.y, self.reg.vertices.y) def test_bounding_box(self): bbox = self.reg.bounding_box assert bbox == BoundingBox(ixmin=1, ixmax=4, iymin=1, iymax=5) def test_to_mask(self): # The true area of this polygon is 3 # We only do very low-precision asserts below, # because results can be unstable with points # on the edge of the polygon. # Basically we check that mask.data is filled # with something useful at all. # Bounding box and output shape is independent of subpixels, # so we only assert on it once here, not in the other cases below mask = self.reg.to_mask(mode='center', subpixels=1) assert 2 <= np.sum(mask.data) <= 6 assert mask.bbox == BoundingBox(ixmin=1, ixmax=4, iymin=1, iymax=5) assert mask.data.shape == (4, 3) # Test more cases for to_mask # This example is with the default: subpixels=5 mask = self.reg.to_mask(mode='subpixels') assert 2 <= np.sum(mask.data) <= 6 mask = self.reg.to_mask(mode='subpixels', subpixels=8) assert 2 <= np.sum(mask.data) <= 6 mask = self.reg.to_mask(mode='subpixels', subpixels=9) assert 2 <= np.sum(mask.data) <= 6 mask = self.reg.to_mask(mode='subpixels', subpixels=10) assert 2 <= np.sum(mask.data) <= 6 with pytest.raises(NotImplementedError): self.reg.to_mask(mode='exact') @pytest.mark.skipif('not HAS_MATPLOTLIB') def test_as_artist(self): patch = self.reg.as_artist() expected = [[1, 1], [3, 1], [1, 4], [1, 1]] assert_allclose(patch.xy, expected) def test_rotate(self): reg = self.reg.rotate(PixCoord(3, 1), -90 * u.deg) assert_allclose(reg.vertices.x, [3, 3, 6]) assert_allclose(reg.vertices.y, [3, 1, 3]) class TestPolygonSkyRegion(BaseTestSkyRegion): reg = PolygonSkyRegion(SkyCoord([3, 4, 3] * u.deg, [3, 4, 4] * u.deg)) expected_repr = (')>') expected_str = ('Region: PolygonSkyRegion\nvertices: ') def test_copy(self): reg = self.reg.copy() assert_allclose(reg.vertices.ra.deg, [3, 4, 3]) assert reg.visual == {} assert reg.meta == {} def test_transformation(self, wcs): pixpoly = self.reg.to_pixel(wcs) assert_allclose(pixpoly.vertices.x, [11.187992, 10.976332, 11.024032], atol=1e-5) assert_allclose(pixpoly.vertices.y, [1.999486, 2.039001, 2.077076], atol=1e-5) poly = pixpoly.to_sky(wcs) # TODO: we should probably assert something about frame attributes, # or generally some better way to check if two SkyCoord are the same? # For now, we use the folloing line to transform back to ICRS (`poly` is in Galactic, same as WCS) poly = PolygonSkyRegion(vertices=poly.vertices.transform_to(self.reg.vertices)) assert_quantity_allclose(poly.vertices.data.lon, self.reg.vertices.data.lon, atol=1e-3 * u.deg) assert_quantity_allclose(poly.vertices.data.lat, self.reg.vertices.data.lat, atol=1e-3 * u.deg) def test_contains(self, wcs): position = SkyCoord([1, 3.25] * u.deg, [2, 3.75] * u.deg) # 1,2 is outside, 3.25,3.75 should be inside the triangle... assert all(self.reg.contains(position, wcs) == np.array([False, True], dtype='bool')) regions-0.4/regions/shapes/tests/test_rectangle.py0000644000076600000240000001456013501414017022536 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from numpy.testing import assert_allclose import pytest import astropy.units as u from astropy.coordinates import SkyCoord from astropy.tests.helper import assert_quantity_allclose from astropy.utils.data import get_pkg_data_filename from astropy.io import fits from astropy.wcs import WCS from ...core import PixCoord from ..rectangle import RectanglePixelRegion, RectangleSkyRegion from ...tests.helpers import make_simple_wcs from .utils import HAS_MATPLOTLIB # noqa from .test_common import BaseTestPixelRegion, BaseTestSkyRegion @pytest.fixture(scope='session') def wcs(): filename = get_pkg_data_filename('data/example_header.fits') header = fits.getheader(filename) return WCS(header) def test_corners(): xc,yc = 2,2 angle = 30*u.deg width = 2 height = 1 reg = RectanglePixelRegion(center=PixCoord(xc, yc), width=width, height=height, angle=angle) y1 = yc + np.cos(angle) * height/2 + np.sin(angle) * width/2 x1 = xc + np.cos(angle) * width/2 - np.sin(angle) * height/2 assert (x1, y1) in reg.corners reg = RectanglePixelRegion(center=PixCoord(xc, yc), width=width, height=height, angle=90*u.deg) # simple case: rotate by 90 np.testing.assert_array_equal([(2.5, 1.), (2.5, 3.), (1.5, 3.), (1.5,1.)], reg.corners) reg = RectanglePixelRegion(center=PixCoord(xc, yc), width=width, height=height, angle=0*u.deg) # simpler case: rotate by 0 np.testing.assert_array_equal([(1, 1.5), (3, 1.5), (3, 2.5), (1, 2.5)], reg.corners) poly = reg.to_polygon() assert len(poly.vertices) == 4 class TestRectanglePixelRegion(BaseTestPixelRegion): reg = RectanglePixelRegion(center=PixCoord(3, 4), width=4, height=3, angle=5 * u.deg) sample_box = [-2, 8, -1, 9] inside = [(4.5, 4)] outside = [(5, 2.5)] expected_area = 12 expected_repr = '' expected_str = ('Region: RectanglePixelRegion\ncenter: PixCoord(x=3, y=4)\n' 'width: 4\nheight: 3\nangle: 5.0 deg') def test_copy(self): reg = self.reg.copy() assert reg.center.xy == (3, 4) assert reg.width == 4 assert reg.height == 3 assert_allclose(reg.angle.to_value("deg"), 5) assert reg.visual == {} assert reg.meta == {} def test_pix_sky_roundtrip(self): wcs = make_simple_wcs(SkyCoord(2 * u.deg, 3 * u.deg), 0.1 * u.deg, 20) reg_new = self.reg.to_sky(wcs).to_pixel(wcs) assert_allclose(reg_new.center.x, self.reg.center.x) assert_allclose(reg_new.center.y, self.reg.center.y) assert_allclose(reg_new.width, self.reg.width) assert_allclose(reg_new.height, self.reg.height) assert_quantity_allclose(reg_new.angle, self.reg.angle) @pytest.mark.skipif('not HAS_MATPLOTLIB') def test_as_artist(self): patch = self.reg.as_artist() # Note: `reg.center` is the center, `patch.xy` is the lower-left corner assert_allclose(patch.xy, (1.138344, 2.331396), atol=1e-3) assert_allclose(patch.get_width(), 4) assert_allclose(patch.get_height(), 3) # `matplotlib.patches.Rectangle` currently doesn't expose `angle`. # See https://github.com/matplotlib/matplotlib/issues/7536 # In the far future, when it's available in the matplotlib versions # we support, we could re-activate a test here. # For now, we could also add an assert on `patch.get_verts()` if # it's considered important to test that the rotation was done # correctly. # assert_allclose(patch._angle, 5) def test_rotate(self): reg = self.reg.rotate(PixCoord(2, 3), 90 * u.deg) assert_allclose(reg.center.xy, (1, 4)) assert_allclose(reg.angle.to_value("deg"), 95) def test_rectangular_pixel_region_bbox(): # odd sizes width = 7 height = 3 a = RectanglePixelRegion(PixCoord(50, 50), width=width, height=height, angle=0.*u.deg) assert a.bounding_box.shape == (height, width) a = RectanglePixelRegion(PixCoord(50.5, 50.5), width=width, height=height, angle=0.*u.deg) assert a.bounding_box.shape == (height + 1, width + 1) a = RectanglePixelRegion(PixCoord(50, 50), width=width, height=height, angle=90.*u.deg) assert a.bounding_box.shape == (width, height) # even sizes width = 8 height = 4 a = RectanglePixelRegion(PixCoord(50, 50), width=width, height=height, angle=0.*u.deg) assert a.bounding_box.shape == (height + 1, width + 1) a = RectanglePixelRegion(PixCoord(50.5, 50.5), width=width, height=height, angle=0.*u.deg) assert a.bounding_box.shape == (height, width) a = RectanglePixelRegion(PixCoord(50.5, 50.5), width=width, height=height, angle=90.*u.deg) assert a.bounding_box.shape == (width, height) class TestRectangleSkyRegion(BaseTestSkyRegion): reg = RectangleSkyRegion( center=SkyCoord(3, 4, unit='deg'), width=4 * u.deg, height=3 * u.deg, angle=5 * u.deg, ) expected_repr = (', width=4.0 deg, height=3.0 ' 'deg, angle=5.0 deg)>') expected_str = ('Region: RectangleSkyRegion\ncenter: \nwidth: ' '4.0 deg\nheight: 3.0 deg\nangle: 5.0 deg') def test_copy(self): reg = self.reg.copy() assert_allclose(reg.center.ra.deg, 3) assert_allclose(reg.width.to_value("deg"), 4) assert_allclose(reg.height.to_value("deg"), 3) assert_allclose(reg.angle.to_value("deg"), 5) assert reg.visual == {} assert reg.meta == {} def test_contains(self, wcs): position = SkyCoord([1, 3] * u.deg, [2, 4] * u.deg) # 1,2 is outside, 3,4 is the center and is inside assert all(self.reg.contains(position, wcs) == np.array([False, True], dtype='bool')) regions-0.4/regions/shapes/tests/test_text.py0000644000076600000240000000505313501650710021555 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from __future__ import absolute_import, division, print_function, unicode_literals import numpy as np from numpy.testing import assert_allclose import pytest from astropy import units as u from astropy.coordinates import SkyCoord from astropy.utils.data import get_pkg_data_filename from astropy.io import fits from astropy.wcs import WCS from ...core import PixCoord from ...tests.helpers import make_simple_wcs from ..text import TextPixelRegion, TextSkyRegion from .test_common import BaseTestPixelRegion, BaseTestSkyRegion @pytest.fixture(scope='session') def wcs(): filename = get_pkg_data_filename('data/example_header.fits') header = fits.getheader(filename) return WCS(header) class TestTextPixelRegion(BaseTestPixelRegion): reg = TextPixelRegion(PixCoord(3, 4), "Sample Text") sample_box = [-2, 8, -1, 9] inside = [] outside = [(3.1, 4.2), (5, 4)] expected_area = 0 expected_repr = '' expected_str = 'Region: TextPixelRegion\ncenter: PixCoord(x=3, y=4)\ntext: Sample Text' def test_copy(self): reg = self.reg.copy() assert reg.center.xy == (3, 4) assert reg.text == "Sample Text" assert reg.visual == {} assert reg.meta == {} def test_pix_sky_roundtrip(self): wcs = make_simple_wcs(SkyCoord(2 * u.deg, 3 * u.deg), 0.1 * u.deg, 20) reg_new = self.reg.to_sky(wcs).to_pixel(wcs) assert_allclose(reg_new.center.x, self.reg.center.x) assert_allclose(reg_new.center.y, self.reg.center.y) def test_rotate(self): reg = self.reg.rotate(PixCoord(2, 3), 90 * u.deg) assert_allclose(reg.center.xy, (1, 4)) class TestTextSkyRegion(BaseTestSkyRegion): reg = TextSkyRegion(SkyCoord(3, 4, unit='deg'), "Sample Text") expected_repr = (', text=Sample Text)>') expected_str = ('Region: TextSkyRegion\ncenter: \ntext: Sample Text') def test_copy(self): reg = self.reg.copy() assert_allclose(reg.center.ra.deg, 3) assert reg.text == "Sample Text" assert reg.visual == {} assert reg.meta == {} def test_contains(self, wcs): position = SkyCoord([1, 2] * u.deg, [3, 4] * u.deg) # Nothing is in a text region assert all(self.reg.contains(position, wcs) == np.array([False, False], dtype='bool')) regions-0.4/regions/shapes/tests/utils.py0000644000076600000240000000024113477731541020702 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst try: import matplotlib # noqa HAS_MATPLOTLIB = True except: HAS_MATPLOTLIB = False regions-0.4/regions/shapes/text.py0000644000076600000240000000652613501414013017354 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst from astropy.wcs.utils import pixel_to_skycoord, skycoord_to_pixel from .point import PointPixelRegion, PointSkyRegion from ..core import PixCoord __all__ = ['TextSkyRegion', 'TextPixelRegion'] class TextPixelRegion(PointPixelRegion): """ A Text string in pixel coordinates Parameters ---------- center : `~regions.PixCoord` The position of the leftmost point of the text string text : `str` The text string. meta : `~regions.RegionMeta` object, optional A dictionary which stores the meta attributes of this region. visual : `~regions.RegionVisual` object, optional A dictionary which stores the visual meta attributes of this region. Examples -------- .. plot:: :include-source: from regions import PixCoord, TextPixelRegion, RegionVisual import matplotlib.pyplot as plt x, y = 15, 10 textangle = '30' fig, ax = plt.subplots(1, 1) center = PixCoord(x=x, y=y) reg = TextPixelRegion(center=center, text="Hello World!", visual=RegionVisual(textangle=textangle)) reg.plot(ax=ax) plt.xlim(10, 30) plt.ylim(2.5, 20) ax.set_aspect('equal') """ def __init__(self, center, text, meta=None, visual=None): super(TextPixelRegion, self).__init__(center, meta, visual) self.text = text self._repr_params = ('text',) def to_sky(self, wcs): center = pixel_to_skycoord(self.center.x, self.center.y, wcs=wcs) return TextSkyRegion(center, self.text) def as_artist(self, origin=(0, 0), **kwargs): """ Matplotlib Text object for this region (`matplotlib.text.Text`). Parameters ---------- origin : array_like, optional The ``(x, y)`` pixel position of the origin of the displayed image. Default is (0, 0). kwargs : `dict` All keywords that a `~matplotlib.text.Text` object accepts Returns ------- text : `~matplotlib.text.Text` Matplotlib Text object. """ from matplotlib.text import Text mpl_params = self.mpl_properties_default('text') mpl_params.update(kwargs) text = Text(self.center.x - origin[0], self.center.y - origin[1], self.text, **mpl_params) return text class TextSkyRegion(PointSkyRegion): """ A Text string in sky coordinates Parameters ---------- center : `~astropy.coordinates.SkyCoord` The position of the leftmost point of the text string text : `str` The text string. meta : `~regions.RegionMeta` object, optional A dictionary which stores the meta attributes of this region. visual : `~regions.RegionVisual` object, optional A dictionary which stores the visual meta attributes of this region. """ def __init__(self, center, text, meta=None, visual=None): super(TextSkyRegion, self).__init__(center, meta, visual) self.text = text self._repr_params = ('text',) def to_pixel(self, wcs): center_x, center_y = skycoord_to_pixel(self.center, wcs=wcs) center = PixCoord(center_x, center_y) return TextPixelRegion(center, self.text, self.meta, self.visual) regions-0.4/regions/tests/0000755000076600000240000000000013501657425015704 5ustar deilstaff00000000000000regions-0.4/regions/tests/__init__.py0000644000076600000240000000017113336761120020006 0ustar deilstaff00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ This packages contains affiliated package tests. """ regions-0.4/regions/tests/coveragerc0000644000076600000240000000107413336761120017743 0ustar deilstaff00000000000000[run] source = regions omit = *tests* *setup_package* regions/version* regions/_astropy_init.py [report] exclude_lines = # Have to re-enable the standard pragma pragma: no cover # Don't complain about packages we have installed except ImportError # Don't complain if tests don't hit assertions raise AssertionError raise NotImplementedError # Don't complain about script hooks def main\(.*\): # Ignore branches that don't pertain to this version of Python pragma: py{ignore_python_version} six.PY{ignore_python_version}regions-0.4/regions/tests/helpers.py0000644000076600000240000000104613477731541017725 0ustar deilstaff00000000000000from __future__ import print_function import numpy as np from astropy.wcs import WCS from astropy import units as u def make_simple_wcs(skycoord, resolution, size): crpix = (size + 1) / 2 cdelt = resolution.to(u.deg).value skycoord_icrs = skycoord.transform_to('icrs') ra = skycoord_icrs.ra.degree dec = skycoord_icrs.dec.degree wcs = WCS(naxis=2) wcs.wcs.crpix = [crpix, crpix] wcs.wcs.cdelt = np.array([-cdelt, cdelt]) wcs.wcs.crval = [ra, dec] wcs.wcs.ctype = ["RA---TAN", "DEC--TAN"] return wcs regions-0.4/regions/tests/setup_package.py0000644000076600000240000000012713477731541021075 0ustar deilstaff00000000000000def get_package_data(): files = ['coveragerc'] return {'regions.tests': files} regions-0.4/regions/version.py0000644000076600000240000001625513501657416016612 0ustar deilstaff00000000000000# Autogenerated by Astropy-affiliated package regions's setup.py on 2019-06-17 09:36:14 UTC from __future__ import unicode_literals import datetime import locale import os import subprocess import warnings def _decode_stdio(stream): try: stdio_encoding = locale.getdefaultlocale()[1] or 'utf-8' except ValueError: stdio_encoding = 'utf-8' try: text = stream.decode(stdio_encoding) except UnicodeDecodeError: # Final fallback text = stream.decode('latin1') return text def update_git_devstr(version, path=None): """ Updates the git revision string if and only if the path is being imported directly from a git working copy. This ensures that the revision number in the version string is accurate. """ try: # Quick way to determine if we're in git or not - returns '' if not devstr = get_git_devstr(sha=True, show_warning=False, path=path) except OSError: return version if not devstr: # Probably not in git so just pass silently return version if 'dev' in version: # update to the current git revision version_base = version.split('.dev', 1)[0] devstr = get_git_devstr(sha=False, show_warning=False, path=path) return version_base + '.dev' + devstr else: # otherwise it's already the true/release version return version def get_git_devstr(sha=False, show_warning=True, path=None): """ Determines the number of revisions in this repository. Parameters ---------- sha : bool If True, the full SHA1 hash will be returned. Otherwise, the total count of commits in the repository will be used as a "revision number". show_warning : bool If True, issue a warning if git returns an error code, otherwise errors pass silently. path : str or None If a string, specifies the directory to look in to find the git repository. If `None`, the current working directory is used, and must be the root of the git repository. If given a filename it uses the directory containing that file. Returns ------- devversion : str Either a string with the revision number (if `sha` is False), the SHA1 hash of the current commit (if `sha` is True), or an empty string if git version info could not be identified. """ if path is None: path = os.getcwd() if not os.path.isdir(path): path = os.path.abspath(os.path.dirname(path)) if sha: # Faster for getting just the hash of HEAD cmd = ['rev-parse', 'HEAD'] else: cmd = ['rev-list', '--count', 'HEAD'] def run_git(cmd): try: p = subprocess.Popen(['git'] + cmd, cwd=path, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) stdout, stderr = p.communicate() except OSError as e: if show_warning: warnings.warn('Error running git: ' + str(e)) return (None, b'', b'') if p.returncode == 128: if show_warning: warnings.warn('No git repository present at {0!r}! Using ' 'default dev version.'.format(path)) return (p.returncode, b'', b'') if p.returncode == 129: if show_warning: warnings.warn('Your git looks old (does it support {0}?); ' 'consider upgrading to v1.7.2 or ' 'later.'.format(cmd[0])) return (p.returncode, stdout, stderr) elif p.returncode != 0: if show_warning: warnings.warn('Git failed while determining revision ' 'count: {0}'.format(_decode_stdio(stderr))) return (p.returncode, stdout, stderr) return p.returncode, stdout, stderr returncode, stdout, stderr = run_git(cmd) if not sha and returncode == 128: # git returns 128 if the command is not run from within a git # repository tree. In this case, a warning is produced above but we # return the default dev version of '0'. return '0' elif not sha and returncode == 129: # git returns 129 if a command option failed to parse; in # particular this could happen in git versions older than 1.7.2 # where the --count option is not supported # Also use --abbrev-commit and --abbrev=0 to display the minimum # number of characters needed per-commit (rather than the full hash) cmd = ['rev-list', '--abbrev-commit', '--abbrev=0', 'HEAD'] returncode, stdout, stderr = run_git(cmd) # Fall back on the old method of getting all revisions and counting # the lines if returncode == 0: return str(stdout.count(b'\n')) else: return '' elif sha: return _decode_stdio(stdout)[:40] else: return _decode_stdio(stdout).strip() # This function is tested but it is only ever executed within a subprocess when # creating a fake package, so it doesn't get picked up by coverage metrics. def _get_repo_path(pathname, levels=None): # pragma: no cover """ Given a file or directory name, determine the root of the git repository this path is under. If given, this won't look any higher than ``levels`` (that is, if ``levels=0`` then the given path must be the root of the git repository and is returned if so. Returns `None` if the given path could not be determined to belong to a git repo. """ if os.path.isfile(pathname): current_dir = os.path.abspath(os.path.dirname(pathname)) elif os.path.isdir(pathname): current_dir = os.path.abspath(pathname) else: return None current_level = 0 while levels is None or current_level <= levels: if os.path.exists(os.path.join(current_dir, '.git')): return current_dir current_level += 1 if current_dir == os.path.dirname(current_dir): break current_dir = os.path.dirname(current_dir) return None _packagename = "regions" _last_generated_version = "0.4" _last_githash = "321666684f4c7bc56ea639e13123d3a0dca689ce" # Determine where the source code for this module # lives. If __file__ is not a filesystem path then # it is assumed not to live in a git repo at all. if _get_repo_path(__file__, levels=len(_packagename.split('.'))): version = update_git_devstr(_last_generated_version, path=__file__) githash = get_git_devstr(sha=True, show_warning=False, path=__file__) or _last_githash else: # The file does not appear to live in a git repo so don't bother # invoking git version = _last_generated_version githash = _last_githash major = 0 minor = 4 bugfix = 0 release = True timestamp = datetime.datetime(2019, 6, 17, 9, 36, 14) debug = False astropy_helpers_version = "2.0.6" try: from ._compiler import compiler except ImportError: compiler = "unknown" try: from .cython_version import cython_version except ImportError: cython_version = "unknown" regions-0.4/setup.cfg0000644000076600000240000000204313501414013014674 0ustar deilstaff00000000000000[build_sphinx] source-dir = docs build-dir = docs/_build all_files = 1 [build_docs] source-dir = docs build-dir = docs/_build all_files = 1 [upload_docs] upload-dir = docs/_build/html show-response = 1 [tool:pytest] minversion = 3.1 norecursedirs = build docs/_build addopts = --arraydiff -p no:warnings doctest_plus = enabled [ah_bootstrap] auto_use = True [metadata] package_name = regions description = Astropy affilated package for region handling author = Astropy developers license = BSD url = http://github.com/astropy/regions edit_on_github = False github_project = astropy/regions [entry_points] [pep8] # E101 - mix of tabs and spaces # W191 - use of tabs # W291 - trailing whitespace # W292 - no newline at end of file # W293 - trailing whitespace # W391 - blank line at end of file # E111 - 4 spaces per indentation level # E112 - 4 spaces per indentation level # E113 - 4 spaces per indentation level # E901 - SyntaxError or IndentationError # E902 - IOError select = E101,W191,W291,W292,W293,W391,E111,E112,E113,E901,E902 exclude = sphinx regions-0.4/setup.py0000755000076600000240000001036613501657346014621 0ustar deilstaff00000000000000#!/usr/bin/env python # Licensed under a 3-clause BSD style license - see LICENSE.rst import glob import os import sys import ah_bootstrap from setuptools import setup #A dirty hack to get around some early import/configurations ambiguities if sys.version_info[0] >= 3: import builtins else: import __builtin__ as builtins builtins._ASTROPY_SETUP_ = True from astropy_helpers.setup_helpers import (register_commands, get_debug_option, get_package_info) from astropy_helpers.git_helpers import get_git_devstr from astropy_helpers.version_helpers import generate_version_py # Get some values from the setup.cfg try: from ConfigParser import ConfigParser except ImportError: from configparser import ConfigParser conf = ConfigParser() conf.read(['setup.cfg']) metadata = dict(conf.items('metadata')) PACKAGENAME = metadata.get('package_name', 'packagename') DESCRIPTION = metadata.get('description', 'Astropy affiliated package') AUTHOR = metadata.get('author', '') AUTHOR_EMAIL = metadata.get('author_email', '') LICENSE = metadata.get('license', 'unknown') URL = metadata.get('url', 'http://astropy.org') # Get the long description from the package's docstring __import__(PACKAGENAME) package = sys.modules[PACKAGENAME] LONG_DESCRIPTION = package.__doc__ # Store the package name in a built-in variable so it's easy # to get from other parts of the setup infrastructure builtins._ASTROPY_PACKAGE_NAME_ = PACKAGENAME # VERSION should be PEP386 compatible (http://www.python.org/dev/peps/pep-0386) VERSION = '0.4' # Indicates if this version is a release version RELEASE = 'dev' not in VERSION if not RELEASE: VERSION += get_git_devstr(False) # Populate the dict of setup command overrides; this should be done before # invoking any other functionality from distutils since it can potentially # modify distutils' behavior. cmdclassd = register_commands(PACKAGENAME, VERSION, RELEASE) # Freeze build information in version.py generate_version_py(PACKAGENAME, VERSION, RELEASE, get_debug_option(PACKAGENAME)) # Treat everything in scripts except README.rst as a script to be installed scripts = [fname for fname in glob.glob(os.path.join('scripts', '*')) if os.path.basename(fname) != 'README.rst'] # Get configuration information from all of the various subpackages. # See the docstring for setup_helpers.update_package_files for more # details. package_info = get_package_info() # Add the project-global data package_info['package_data'].setdefault(PACKAGENAME, []) package_info['package_data'][PACKAGENAME].append('data/*') # Define entry points for command-line scripts entry_points = {'console_scripts': []} entry_point_list = conf.items('entry_points') for entry_point in entry_point_list: entry_points['console_scripts'].append('{0} = {1}'.format(entry_point[0], entry_point[1])) # Include all .c files, recursively, including those generated by # Cython, since we can not do this in MANIFEST.in with a "dynamic" # directory name. c_files = [] for root, dirs, files in os.walk(PACKAGENAME): for filename in files: if filename.endswith('.c'): c_files.append( os.path.join( os.path.relpath(root, PACKAGENAME), filename)) package_info['package_data'][PACKAGENAME].extend(c_files) # Note that requires and provides should not be included in the call to # ``setup``, since these are now deprecated. See this link for more details: # https://groups.google.com/forum/#!topic/astropy-dev/urYO8ckB2uM setup(name=PACKAGENAME, version=VERSION, description=DESCRIPTION, scripts=scripts, setup_requires=['numpy'], install_requires=['numpy', 'astropy', 'six'], extras_require=dict( plot=[ 'matplotlib', ], test=[ 'pytest-mpl', 'pytest-arraydiff' ], ), author=AUTHOR, author_email=AUTHOR_EMAIL, license=LICENSE, url=URL, long_description=LONG_DESCRIPTION, cmdclass=cmdclassd, zip_safe=False, use_2to3=False, entry_points=entry_points, python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*', **package_info )