# Path: retina/screen/screen.py
# class Screen(object):
# class SphereScreen(Screen):
# class CylinderScreen(Screen):
#     def __init__(self, config):
#     def screen_to_image_map(self):
#     def grid(self):
#     def _setup_screen(self, config):
#     def setup_file(self, filename, read=False):
#     def get_screen_intensity_steps(self, num_steps):
#     def get_image2d_dim(self):
#     def generate_video(self, data, coordinates, rng, videofile):
#     def close_files(self):
#     def __init__(self, config):
#     def _generate_grid(self):
#     def get_image2d_dim(self):
#     def radius(self):
#     def grid(self):
#     def screen_to_image_map(self):
#     def generate_video(self, data, coordinates, rng, videofile):
#     def __init__(self, config):
#     def _generate_grid(self):
#     def get_image2d_dim(self):
#     def grid(self):
#     def screen_to_image_map(self):
#     def radius(self):
#     def height(self):
#     def generate_video(self, data, coordinates, rng, videofile):
# def screenfactory(screen_type):
# def main():
#         U, V = np.mgrid[0:np.pi/2:complex(0, 60),
#                         0:2*np.pi:complex(0, 60)]
#         X = np.cos(V)*np.sin(U)
#         Y = np.sin(V)*np.sin(U)
#         Z = np.cos(U)
#         C = self._height  # number of columns
#         P = self._width   # number of parallels
#         H = self._length  # length (or height) of cylinder -> this is y
#         X = radius*np.cos(Theta)
#         Y = radius*np.sin(Theta)
# 
# Path: retina/screen/map/mapimpldr.py
# PI = np.pi
#     D = b*b - a*c
#     MIN_LEN = np.tan(PI/180)
# def solve_quadratic(a, b, c):
#     def __init__(self, r1, r2):
#     def from_retina_screen(cls, retina, screen):
#     def map_aux(elev, azim, delev, dazim, r1, r2):
#     def map(self, elev, azim, delev, dazim):
#     def invmap(self, elev, azim, delev, dazim):
#     def __init__(self, r1, r2):
#     def from_retina_screen(cls, retina, screen):
#     def map(self, elev, azim, delev, dazim):
#     def invmap(self, z, theta):
# class SphereToSphereMap(PointMapWithDirection):
# class SphereToCylinderMap(PointMapWithDirection):
# 
# Path: retina/vrf/vrf.py
# PI = np.pi
#         M = int(kwargs.get('M', 1))
#         M = int(kwargs.get('M', 1))
#     S1 = 128
#     S2 = 128
#     PHOTORECEPTORS = 8
#     RAD = 1
#     KAPPA = 20
#     SIGMA = 1  # or angle
#     NTHREADS = (128, 1, 1)
#     NBLOCKS = ((M_size-1) // NTHREADS[0] + 1, 1)
# class RF(object):
# class Sphere_Gaussian_RF(RF):
# class Cylinder_Gaussian_RF(RF):
#     def __init__(self, grid):
#     def load_kernel(self):
#     def to_gpu(self):
#     def _load_gpu(self):
#     def load_parameters(self, **kwargs):
#     def refa(self):
#     def refb(self):
#     def _call_filter_func(self, N_filters, startbias):
#     def generate_filters(self, N_filters=None, startbias=0):
#     def filter(self, video_input):
#     def filter_image(self, image_input):
#     def filter_image_use(self, image_input):
#     def __init__(self, grid):
#     def load_kernel(self):
#     def to_gpu(self):
#     def load_parameters(self, **kwargs):
#     def refa(self):
#     def refb(self):
#     def _call_filter_func(self, N_filters, startbias):
#     def __init__(self, grid):
#     def load_kernel(self):
#     def to_gpu(self):
#     def load_gpu(self):
#     def load_parameters(self, **kwargs):
#     def refa(self):
#     def refb(self):
#     def _call_filter_func(self, N_filters, startbias):
# def _get_von_mises_fisher_rf(dtype):
# def _get_gaussian_cylinder(dtype):
# 
# Path: retina/vrf/vrf_no_gpu.py
# class RF(object):
# class Sphere_Gaussian_RF(RF):
# class Cylinder_Gaussian_RF(RF):
#     def __init__(self, grid):
#     def load_parameters(self, **kwargs):
#     def refa(self):
#     def refb(self):
#     def compute_filters(self):
#     def filter(self, video_input):
#     def filter_image(self, image_input):
#     def __init__(self, grid):
#     def refa(self):
#     def refb(self):
#     def load_parameters(self, **kwargs):
#     def _generate_filter(self, i):
#     def __init__(self, grid):
#     def refa(self):
#     def refb(self):
#     def load_parameters(self, **kwargs):
#     def _generate_filter(self, i):
#     ONE_OVER_TWO_PI = 0.159154943091895
#         M = int(kwargs.get('M', 1))
#     ONE_OVER_TWO_PI = 0.159154943091895
#         M = int(kwargs.get('M', 1))


from .screen import screen as scr
from .screen.map import mapimpldr as mapdr
from .vrf import vrf as vrf
from .vrf import vrf_no_gpu as vrfn

CYLINDER = 'Cylinder'
SPHERE = 'Sphere'


_scr_class_dict = {
    CYLINDER: scr.CylinderScreen,

# Path: retina/screen/screen.py
# class Screen(object):
# class SphereScreen(Screen):
# class CylinderScreen(Screen):
#     def __init__(self, config):
#     def screen_to_image_map(self):
#     def grid(self):
#     def _setup_screen(self, config):
#     def setup_file(self, filename, read=False):
#     def get_screen_intensity_steps(self, num_steps):
#     def get_image2d_dim(self):
#     def generate_video(self, data, coordinates, rng, videofile):
#     def close_files(self):
#     def __init__(self, config):
#     def _generate_grid(self):
#     def get_image2d_dim(self):
#     def radius(self):
#     def grid(self):
#     def screen_to_image_map(self):
#     def generate_video(self, data, coordinates, rng, videofile):
#     def __init__(self, config):
#     def _generate_grid(self):
#     def get_image2d_dim(self):
#     def grid(self):
#     def screen_to_image_map(self):
#     def radius(self):
#     def height(self):
#     def generate_video(self, data, coordinates, rng, videofile):
# def screenfactory(screen_type):
# def main():
#         U, V = np.mgrid[0:np.pi/2:complex(0, 60),
#                         0:2*np.pi:complex(0, 60)]
#         X = np.cos(V)*np.sin(U)
#         Y = np.sin(V)*np.sin(U)
#         Z = np.cos(U)
#         C = self._height  # number of columns
#         P = self._width   # number of parallels
#         H = self._length  # length (or height) of cylinder -> this is y
#         X = radius*np.cos(Theta)
#         Y = radius*np.sin(Theta)
# 
# Path: retina/screen/map/mapimpldr.py
# PI = np.pi
#     D = b*b - a*c
#     MIN_LEN = np.tan(PI/180)
# def solve_quadratic(a, b, c):
#     def __init__(self, r1, r2):
#     def from_retina_screen(cls, retina, screen):
#     def map_aux(elev, azim, delev, dazim, r1, r2):
#     def map(self, elev, azim, delev, dazim):
#     def invmap(self, elev, azim, delev, dazim):
#     def __init__(self, r1, r2):
#     def from_retina_screen(cls, retina, screen):
#     def map(self, elev, azim, delev, dazim):
#     def invmap(self, z, theta):
# class SphereToSphereMap(PointMapWithDirection):
# class SphereToCylinderMap(PointMapWithDirection):
# 
# Path: retina/vrf/vrf.py
# PI = np.pi
#         M = int(kwargs.get('M', 1))
#         M = int(kwargs.get('M', 1))
#     S1 = 128
#     S2 = 128
#     PHOTORECEPTORS = 8
#     RAD = 1
#     KAPPA = 20
#     SIGMA = 1  # or angle
#     NTHREADS = (128, 1, 1)
#     NBLOCKS = ((M_size-1) // NTHREADS[0] + 1, 1)
# class RF(object):
# class Sphere_Gaussian_RF(RF):
# class Cylinder_Gaussian_RF(RF):
#     def __init__(self, grid):
#     def load_kernel(self):
#     def to_gpu(self):
#     def _load_gpu(self):
#     def load_parameters(self, **kwargs):
#     def refa(self):
#     def refb(self):
#     def _call_filter_func(self, N_filters, startbias):
#     def generate_filters(self, N_filters=None, startbias=0):
#     def filter(self, video_input):
#     def filter_image(self, image_input):
#     def filter_image_use(self, image_input):
#     def __init__(self, grid):
#     def load_kernel(self):
#     def to_gpu(self):
#     def load_parameters(self, **kwargs):
#     def refa(self):
#     def refb(self):
#     def _call_filter_func(self, N_filters, startbias):
#     def __init__(self, grid):
#     def load_kernel(self):
#     def to_gpu(self):
#     def load_gpu(self):
#     def load_parameters(self, **kwargs):
#     def refa(self):
#     def refb(self):
#     def _call_filter_func(self, N_filters, startbias):
# def _get_von_mises_fisher_rf(dtype):
# def _get_gaussian_cylinder(dtype):
# 
# Path: retina/vrf/vrf_no_gpu.py
# class RF(object):
# class Sphere_Gaussian_RF(RF):
# class Cylinder_Gaussian_RF(RF):
#     def __init__(self, grid):
#     def load_parameters(self, **kwargs):
#     def refa(self):
#     def refb(self):
#     def compute_filters(self):
#     def filter(self, video_input):
#     def filter_image(self, image_input):
#     def __init__(self, grid):
#     def refa(self):
#     def refb(self):
#     def load_parameters(self, **kwargs):
#     def _generate_filter(self, i):
#     def __init__(self, grid):
#     def refa(self):
#     def refb(self):
#     def load_parameters(self, **kwargs):
#     def _generate_filter(self, i):
#     ONE_OVER_TWO_PI = 0.159154943091895
#         M = int(kwargs.get('M', 1))
#     ONE_OVER_TWO_PI = 0.159154943091895
#         M = int(kwargs.get('M', 1))


# Path: retina/classmapper.py
from .screen import screen as scr
from .screen.map import mapimpldr as mapdr
from .vrf import vrf as vrf
from .vrf import vrf_no_gpu as vrfn


CYLINDER = 'Cylinder'
SPHERE = 'Sphere'


_scr_class_dict = {
    CYLINDER: scr.CylinderScreen,

    SPHERE: scr.SphereScreen