# -*- coding: utf-8 -*-

import __main__

import numpy

import pylab

import os.path

import os

import copy

#import pdb

import param

import topo.pattern

import topo.command.analysis

from math import pi, sqrt, exp, pow

from numpy.oldnumeric import zeros, Float, sum

from topo.projection import CFProjection, SharedWeightCFProjection

from topo.base.boundingregion import BoundingBox

from topo import numbergen

from topo.pattern import Gaussian, Selector, Null

from topo.transferfn import DivisiveNormalizeL1, HomeostaticMaxEnt, TransferFnWithState, Sigmoid, PiecewiseLinear

from topo.base.arrayutil import clip_lower

from topo.sheet.lissom import LISSOM

from topo.sheet.optimized import NeighborhoodMask_Opt, LISSOM_Opt

from topo.plotting.plotfilesaver import *

from topo.command.pylabplot import cyclic_tuning_curve, matrixplot

from topo.command.analysis import save_plotgroup

from param import normalize_path

from topo.command.pylabplot import plot_tracked_attributes

from topo.base.functionfamily import CoordinateMapperFn,TransferFn

from topo.plotting.bitmap import MontageBitmap

from topo.base.patterngenerator import PatternGenerator, Constant

from topo.transferfn import Sigmoid

import matplotlib

matplotlib.use('Agg')

from pylab import *

from matplotlib import *

def save_tuning_curve_data(filename, sheet, x_axis, curve_label, x, y):

return aa

def get_tuning_curve_data(sheet, x_axis, curve_label, x, y):

return [x_values, y_values]

def save_tuning_curves(prefix):

fit_curves(directory, filename, prefix)

def fit_curves(directory, filename, prefix):

print "END"

def pokus():

data = [[0.023333, 0.046667, 0.070000, 0.093333, 0.116667, 0.140000, 0.163333, 0.186667, 0.210000, 0.233333, 0.256667, 0.280000, 0.303333, 0.326667, 0.350000, 0.373333, 0.396667, 0.420000, 0.443333, 0.466667, 0.490000, 0.513333, 0.536667, 0.560000, 0.583333, 0.606667, 0.630000, 0.653333, 0.676667, 0.700000], [0.000000, 0.140682, 0.323128, 0.381151, 0.453309, 0.495148, 0.511234, 0.503472, 0.476296, 0.452621, 0.421329, 0.391765, 0.378917, 0.358795, 0.345896, 0.327351, 0.318290, 0.308762, 0.297803, 0.292149, 0.285739, 0.281539, 0.274593, 0.272147, 0.266158, 0.263694, 0.259160, 0.255340, 0.252024, 0.248111]]

def DoG(Input, Rz, Ke, Ki, alpha, beta):

return x

def DoGfreq(Input, Rz, Ke, Ki, alpha, beta):

return x

def fitDoG(x, Input, Actual_Output):

return s

def fitDoGfreq(x, Input, Actual_Output):

return s

def save_plots(prefix):

p.save_to_disk()

def AddV2():

#topo.sim.schedule_command(40000,LE+'.change_bounds(BoundingBox(radius=0.00174))')

#global parameter holding the activities

activity_history = numpy.array([])

def collect_activity_statistics():

save_plotgroup('Activity')

def homeostatic_analysis_function():

#plot_tracked_attributes(output_fn=topo.sim["V1"].output_fn.output_fns[2], init_time=0, final_timetopo.sim.time(), filename="V1", ylabel="V1")

class SimpleHomeoSigmoid(TransferFnWithState):

super(SimpleHomeoSigmoid, self).state_pop()

class SimpleHomeoLinear(TransferFnWithState):

super(SimpleHomeoLinear, self).state_pop()

class Jitter(CoordinateMapperFn):

return x + (self.rand() - 0.5) * self.scale, y + (self.rand() - 0.5) * self.scale

current_histogram = []

activity_queue = []

call_time = 0

def update_histogram(sheet_name="V1"):

print contrib.jacommands.current_histogram

activities = []

def collect_activity(sheet_name):

import contrib.jacommands

contrib.jacommands.activities.insert(0, topo.sim[sheet_name].activity.copy())

def measure_histogram(iterations=1000, sheet_name="V1"):

return bins

def enable_movie():

name='V1 Activity')

def save_movie():

movie.save()

def randomize_V1Simple_relative_LGN_strength(sheet_name="V1Simple", prob=0.5):

#cf_off.weights*=(1-a)

import topo.transferfn

import topo.transferfn.misc

ActivityHysteresis = topo.transferfn.Hysteresis

SimpleHomeoLinearRelative = topo.transferfn.misc.HomeostaticResponse

def _divide_with_constant(x, y):

y = numpy.clip(y, 0, 10000)

x = numpy.clip(x, 0, 10000)

return numpy.divide(x, y + __main__.__dict__.get('LGNGain',0.11))

def add_gc(sheet_name, surround_gaussian_size=0.5, strength=0.63):

topo.sim[sheet_name].strict_tsettle = 1

def AddGC(surround_gaussian_size=__main__.__dict__.get('SurrSize',0.5), strength=__main__.__dict__.get('LatLGNStr',0.63)):

add_gc('LGNOn',surround_gaussian_size,strength)

add_gc('LGNOff',surround_gaussian_size,strength)

#class Habituation(TransferFnWithState):

# """

# This output function allows the activity to be smoothly interpolated between

# individual time step of the simulation. The time_constant paremater controls the

# time scale of this interpolation.

# """

#

# smoothing = param.Number(default=0.99, doc="""The time constant defining the width of the window over which activity is averaged""")

# alpha = param.Number(default=1.0, doc="""This parameter defines how strong influence on the output of the neuron does the habituation has """)

#

# def __init__(self, **params):

# super(Habituation, self).__init__(**params)

# self.first_call = True

# self.y_avg = 0

#

# def __call__(self, x):

# if (self.first_call == True):

# self.old_a = x.copy() * 0.0

# self.first_call = False

#

# x_orig = copy(x)

# if self.plastic:

# self.y_avg = (1.0 - self.smoothing) * x + self.smoothing * self.y_avg

#

# x -= self.alpha * self.y_avg

# x -= x * ((x <= 0) * 1.0)

class Translator(PatternGenerator):

return generator(xdensity=xdensity, ydensity=ydensity, bounds=bounds, x=self.x + t * cos(self.inspect_value("orientation") + pi / 2) * self.speed, y=self.y + t * sin(self.inspect_value("orientation") + pi / 2) * self.speed, orientation=self.inspect_value("orientation"), index=self.inspect_value("index"))#,scale=self.inspect_value("scale"))

class Expander(PatternGenerator):

size=self.size + t * self.speed,index=self.index)

class Jitterer(PatternGenerator):

return generator(xdensity=xdensity, ydensity=ydensity, bounds=bounds, x=self.x + self.jitter_magnitude * self.r(), y=self.y + self.jitter_magnitude * self.r(), orientation=self.inspect_value("orientation"), index=self.inspect_value("index"))

class SequenceSelector(PatternGenerator):

return image_array

def measure_ot(lat_exc, lat_inh, e, t):

topo.commands.pylabplot.cyclic_tuning_curve(suffix="GC_with_LGNGC_HR", filename=filename, sheet=topo.sim["V1"], coords=[(0, 0)], x_axis="orientation")

def plot_linearized_rfs(sheet_name="V1Simple", lgn_on_projection_name="LGNOnAfferent", lgn_off_projection_name="LGNOffAfferent"):

RF += on_cfs.weights[lx, ly] * topo.sim["LGNOn"].projections["Afferent"].cfs[0, 0].weights

def plot_proj_activity_sum(sheet, lateral_proj=[]):

pylab.show()

def create_prefix(variables):

return prefix

#run_combinations_counter=0

def _run_combinations_rec(func, param, params, index):

_run_combinations_rec(func, new_param, params, index + 1)

def run_combinations(func, params):

_run_combinations_rec(func, [], params, 0)

def investigate_neuron(coordx,coordy):