#include "sys.hpp"   // for libcwd
#include "debug.hpp" // for libcwd

#include <map>

#include "input.hpp"
#include "simloop.hpp"

using namespace std;

typedef map<string,InputMode> TStringToInputModeMap;
const TStringToInputModeMap::value_type stringToInputMode[] = {
    TStringToInputModeMap::value_type("Default"       ,csimInputDefault),
    TStringToInputModeMap::value_type("Test"          ,csimInputTest),
    TStringToInputModeMap::value_type("Remote"        ,csimInputRemote),
    TStringToInputModeMap::value_type("Random"        ,csimInputRandom),
    TStringToInputModeMap::value_type("RandomSequence",csimInputRandomSequence),
    TStringToInputModeMap::value_type("Direct"        ,csimInputDirect),
    TStringToInputModeMap::value_type("Saccades"      ,csimInputSaccades),
    TStringToInputModeMap::value_type("SaccTest"      ,csimInputSaccTest),
    TStringToInputModeMap::value_type("SlideWinPic"   ,csimInputSlideWinPic),
    TStringToInputModeMap::value_type("PlayMovie"     ,csimInputPlayMovie),
    TStringToInputModeMap::value_type("Sequence"      ,csimInputSequence),
};

const int numInputModeElems = sizeof stringToInputMode / sizeof stringToInputMode[0];
InputMode InputModeFromString(string modeString)
{
    static  TStringToInputModeMap myMap (stringToInputMode, stringToInputMode + numInputModeElems);
    if (myMap.count(modeString) == 1) {
      return myMap[modeString];
    } else {
      return csimInputDefault;
    }
}


input::input(layer* tg,
             csimInputChannel _InputNumber,
             float strength,
             int size,
             int start)
: SimElement(seInput),
Target(tg),
Strength(strength),
Size(size),
Start(start),
InputNumber(_InputNumber),
inpsync(0),
mode(csimInputDefault),
isi(false),
CurStimNr(0),
StimSeq(0),
ResetToBeDone(false),
mSilent(false)
{
    int i;
    RecordBuffer = new int [MacroTimeStep];

    for (i=0;i<MacroTimeStep;++i) RecordBuffer[i] = -1; // input indices start with 0

    Dout(dc::input, "Input::Strength = " << Strength);

    dt = Target->GetDt();

    InputPointer = Target->GetInputPointer(InputNumber);

    if (Size >= Target->N) {
        Dout(dc::input, "input::input: size (=" <<  Size << ") too large");
        Size=Target->N /2;
        Dout(dc::input, ", set it to Target->N/2 (=" << Size << ")");
    }

    if (Start + Size >= Target->N) {
        Start = 0;
        Dout(dc::input, "input::input: pattern start too high; set it to 0");
    }

    Stop = Start+Size;
}


input::~input()
{
}

int input::WriteSimInfo(fstream &fw)
{
    stringstream sstr;
    sstr << "<Target id=\"" << Target->IdNumber << "\"/> \n";
    sstr << "<InputStrength value=\"" << Strength << "\"/> \n";
    SimElement::WriteSimInfo(fw, sstr.str());
}

int input::WriteSimInfo(fstream &fw, const string &ChildInfo)
{
    stringstream sstr;
    sstr << "<Target id=\"" << Target->IdNumber << "\"/> \n";
    sstr << "<InputStrength value=\"" << Strength << "\"/> \n";
    sstr << ChildInfo;
    SimElement::WriteSimInfo(fw, sstr.str());
}


int input::proceede(int TotalTime)
{
    for (int i=Start; i<Stop;++i) InputPointer[i] += Strength;
}

int input::prepare(int StepNum)
{
    FileName = Name + ".inp.dat";
    FILE *fs;
    std::string tmpstring = DataDirectory+FileName+SimTag;
    const char* fname = tmpstring.c_str();
    Dout(dc::input, "input::prepare");
    if (StepNum ==0) {
        fs = fopen(fname,"w");

    }  else  {
        fs = fopen(fname,"a");
    }

    if (fs) {
        fwrite(RecordBuffer, MacroTimeStep*sizeof(*RecordBuffer), 1, fs);
        fclose(fs);

    } else {
        cerr << "ERROR: failed opening file " << fname << "\n";
        fflush(stdout);
    }

    int i;

    for (i=0;i<MacroTimeStep;++i) RecordBuffer[i] = -1;
}

int input::GetCurStimNr()
{
    return CurStimNr;
}

int input::GetLastStim()
{
    if (!isi) return CurStimNr+1;
    else return 0;
}

int input::SetInputSync(InputSynchronizer* _inpsync)
{
    inpsync=_inpsync;
}

void input::SetMode(InputMode _mode)
{
    mode=_mode;

    if (mode == csimInputRemote && inpsync==0) {
        cerr << "ERROR: inpsync nicht initialisiert!!!\n";
        mode = csimInputDefault;
    }
}


int input::GetNStimuli()
{
    cerr << "ERROR in int input::GetNStimuli(): this is an abstract method, derived classes should overwrite this, returning -1 as default\n";
    return -1;
}

/////////////////////////////

InputSynchronizer::InputSynchronizer(input* _Master, ResponseMap* _rmap)
        : Master(_Master), rmap(_rmap)
{
}

int InputSynchronizer::GetRemoteStimNr()
{
    if (rmap) return (*rmap)[Master->GetLastStim()];
    else return Master->GetLastStim();
}

////////////////////


BidirSequenceInput::BidirSequenceInput(): Direction(CSIM_right)
{
}

void BidirSequenceInput::ChangeDir()
{
    Direction = -Direction;
}

void BidirSequenceInput::RandomDir()
{
    if (getrandom(2)) Direction=CSIM_left;
    else Direction=CSIM_right;
}



///////////////////////

SequenceInput::SequenceInput(layer* tg, csimInputChannel InputNumber, float strength, int size, int numpt, float ov, int dur):
        input(tg, InputNumber, strength, size), NumPatterns(numpt), Overlap(ov), Duration(dur)
{
    PtPointer = 0;
    Duration = int(float(Duration)/dt);
    Hold = Duration;
    PtShift = int((1.-Overlap)*Size);

    if ((NumPatterns*PtShift+Size) > Target->N) NumPatterns = (Target->N-Size)/PtShift;

    Dout(dc::input, "Initializing Sequence Input; Target->N=" << Target->N << " PtShift= "<< PtShift<< " Size=" << Size);
}

SequenceInput::~SequenceInput()
{

}

int SequenceInput::proceede(int TotalTime)
{
    if (--Hold <1) {
        PtPointer = (PtPointer +Direction+NumPatterns) % NumPatterns;
        Hold = Duration;
    }

    Start = PtShift*PtPointer;

    Stop = Start+Size;

    if (Stop >= Target->N) {
        Dout(dc::input, "SequenceInputError");
    }

    for (int i=Start; i<Stop;++i) InputPointer[i] += Strength;
}



////////////////////////////


LearnTestInput::LearnTestInput(layer* _TargetLayer, csimInputChannel InputNumber, float _strength, float _delayms, float _isims): input(_TargetLayer, InputNumber, _strength)
{
    delay = int(_delayms/dt);
    isi = int(_isims/dt);

    if (isi < delay) {
        Dout(dc::input, "ERROR: Setting isi to delay value");
        isi = delay;
    }

    if (Target->N < 2) Dout(dc::input, "ERROR: Target Layer too small!!!");

    phase =0;

    hold = isi;

    Dout(dc::input, "LearnTestInput: delay =" << delay << "  isi= " << isi);
}

LearnTestInput::~LearnTestInput()
{
}

int LearnTestInput::proceede(int TotalTime)
{
    if (hold-- == 0) {
        if (phase==0) {
            hold = delay;
            InputPointer[0] += Strength;
            phase=1;
            Dout(dc::input, "first");

        } else {
            hold == isi;
            InputPointer[1] += Strength;
            phase=0;
            Dout(dc::input, "second");
        }
    }
}

/////////////////////////////////////////////

PatternSequenceInput::PatternSequenceInput(layer* tg, csimInputChannel InputNumber, float strength, int size, int _PtStart, int numpt, float ov, int dur): input(tg, InputNumber, strength, size), NumPatterns(numpt), Overlap(ov), Duration(dur)
{
    CurStimNr = 0;
    Start = _PtStart;
    Duration = int(float(Duration)/dt);
    Hold = Duration;
    PtShift = int((1.-Overlap)*Size);

    if ((NumPatterns*PtShift+Size) > Target->N) NumPatterns = (Target->N-Size)/PtShift;

    NewArray2d(PatternArray, NumPatterns, Size);

    int i,j;

    int mod = NumPatterns*PtShift;

    int CurNum;

    for (i=0;i<NumPatterns;++i) for (j=0;j<Size;++j) {
            CurNum= Start+(((PtShift*i) + j) % mod);

            if (CurNum < Target->N) PatternArray[i][j] = CurNum;
            else {
                PatternArray[i][j]=0;
                Dout(dc::input, "ERROR: InputPattern out of Range");
            }
        }
}


PatternSequenceInput::~PatternSequenceInput()
{
    DeleteArray2d(PatternArray, NumPatterns);
}


int PatternSequenceInput::proceede(int TotalTime)
{
    if (--Hold <1) {
        CurStimNr = (CurStimNr +Direction+ NumPatterns) % NumPatterns;
        Hold = Duration;
    }

    for (int i=0; i<Size;++i) InputPointer[PatternArray[CurStimNr][i]] += Strength;
}


void PatternSequenceInput::Jump()
{
    CurStimNr = getrandom(NumPatterns);
}

///////////////////////////////////////////
PictureSequenceInput::PictureSequenceInput(layer* tg, csimInputChannel InputNumber, float strength, float _StimDur, float _Isi1Dur, float _NoJumpDur, float _Isi2Dur, float _BackgroundStrength): input(tg, InputNumber, strength), NoJumpDuration(int(_NoJumpDur)), IsiHold(0), mBackgroundStrength(_BackgroundStrength)
{
    PictureArray = 0;
    Npictures=0;

    // Timing parameters
    StimDuration=int(_StimDur/dt);
    StimHold = StimDuration;
    //  NoJumpDuration = int(_NoJumpDur/_StimDur);
    NoJumpHold = NoJumpDuration;
    CurStimNr=0;
    Isi1Duration = int(_Isi1Dur/dt);
    Isi2Duration = int(_Isi2Dur/dt);
    TestMode=false;
}

PictureSequenceInput::~PictureSequenceInput()
{
}


void PictureSequenceInput::SetGaussPictureArray(const vector<vector2d> &mpList, float Sigma, float Cut)
{
    // ToDo: Check wether Target-Neuron positions are allready set up
    int i,j;
//     double ix,iy;
    Dout(dc::input, "PictureSequenceInput::SetGaussPictureArray");
    Npictures =mpList.size();
    NewArray2d(PictureArray, Npictures, Target->N);

    if (Target->Nx >0 && Target->Ny > 0) {
//   int radius = min(Target->Nx, Target->Ny)/2;
        float dist;
        vector2d mp;
        float MaxDist ;
        MaxDist = Cut*Sigma;
        //if (Target->NormPos) MaxDist = 0.25; else MaxDist=Target->Nx/4;
        vector2d basis = vector2d(Target->Nx, Target->Ny);

        if (Target->NormPos) basis = vector2d(1,1);

        Dout(dc::input, "NormPos=" << Target->NormPos << " MaxDist=" << MaxDist << "Sigma=" << Sigma);

        for (i=0;i<Npictures;++i) {
            mp = mpList[i];
            Dout(dc::input, "MPx=" << mp.x << "MPy=" << mp.y);

            for (j=0;j<Target->N;++j) {
                dist = (Target->Pos[j]).CyclicDistance(mp, basis);

                if (dist < MaxDist) PictureArray[i][j] = gauss(dist/MaxDist, Sigma);
                else PictureArray[i][j] =0;
            }
        }
    }
}

void PictureSequenceInput::SetCirclePictureArray(const vector<vector2d> &mpList, float Radius, float Background)
{
    // ToDo: Check wether Target-Neuron positions are allready set up
    int i,j;
    Npictures =mpList.size();
    NewArray2d(PictureArray, Npictures, Target->N);
    Dout(dc::input, "PictureSequenceInput::SetCirclePictureArray, Npictures=" << Npictures);

    if (Target->Nx >0 && Target->Ny > 0) {
        float dist;
        vector2d mp;
        vector2d basis = vector2d(Target->Nx, Target->Ny);

        if (Target->NormPos) basis = vector2d(1,1);

        Dout(dc::input, "NormPos=" << Target->NormPos << "Radius=" << Radius);

        for (i=0;i<Npictures;++i) {
            mp = mpList[i];
            Dout(dc::input, "MPx=" << mp.x << "MPy=" << mp.y);

            for (j=0;j<Target->N;++j) {
                dist = (Target->Pos[j]).CyclicDistance(mp, basis);

                if (dist < Radius) PictureArray[i][j] = 1;
                else PictureArray[i][j] =Background;
            }
        }
    }
}



void PictureSequenceInput::SetPictureArray(vector<vector<float> > &paVec)
{
    Npictures = paVec.size();  // paVec
    NewArray2d(PictureArray, Npictures, Target->N);

    for (int i=0;i<Npictures;++i) {
        int NeuronNumber=0;

        for (vector<float>::iterator it=paVec[i].begin();it<paVec[i].end();++it) {
            if (NeuronNumber<Target->N) PictureArray[i][NeuronNumber++] = (*it);
        }
    }
}

void PictureSequenceInput::SetPictureArray(ObjMovie *Movie)
{
    int FilterNr=0;
    int FrameSize = Movie->GetFrameSize(FilterNr);
    float* Data;

    if (FrameSize != Target->N) {
        Dout(dc::input, "[PictureSequenceInput] Warning: FrameSize=" << FrameSize << " != Target->N =" << Target->N);
    }

    Npictures = Movie->GetNFrames();

    NewArray2d(PictureArray, Npictures, Target->N);

    for (int i=0;i<Npictures;++i) {
        Movie->GotoFrameNr(i);
        Data = Movie->GetFramePointer(FilterNr);

        for (int pix=0;pix<Target->N;++pix) {
            if (pix<Target->N) PictureArray[i][pix] = Data[pix];
        }
    }
}


void PictureSequenceInput::SetPictureArray(int _Npic, float _mpy, float Sigma)
{
    int i,j;
    double ix,iy;

    if (PictureArray != 0) Dout(dc::input|dc::warning, "ERROR: PictureArray != 0 (picture array allready initialized)");

    Npictures = _Npic;

    bool NormPos = (Sigma<1);

    Dout(dc::input, "PictureSequenceInput::SetPictureArray");

    Dout(dc::input, "Npic=" << _Npic << " mpy=" << _mpy << "NormPos=" << NormPos);

    NewArray2d(PictureArray, Npictures, Target->N);

    vector<vector2d> mpList;

    if (Target->Nx >0 && Target->Ny > 0) {
//   int radius = min(Target->Nx, Target->Ny)/2;
        float dist;
        vector2d mp;
        float MaxDist ;

        if (NormPos) MaxDist= Target->Nx/4;
        else MaxDist = 0.25;

        vector2d basis = vector2d(Target->Nx, Target->Ny);

        if (NormPos) basis = vector2d(1,1);

        for (i=0;i<Npictures;++i) {
            if (NormPos) mp = vector2d((float(i)/Npictures),_mpy);
            else mp = vector2d((3*Target->Nx/4 + Target->Nx*i/Npictures)
                                   % Target->Nx,_mpy*Target->Ny);

//         cout << "i=" << i << "mp.x=" << mp.x << "mp.y="
//       << mp.y << " i/Npictures= " << float(i)/Npictures << "\n";
            mpList.push_back(mp);
        }

        SetGaussPictureArray(mpList, Sigma);
    }
}


void PictureSequenceInput::SetCirclePictureArray(int _Npic, float _mpx, float Radius, float Background)
{
    int i,j;
    double ix,iy;

    if (PictureArray != 0) {
        Dout(dc::input|dc::warning, "ERROR: PictureArray != 0 (picture array allready initialized)");
    }

    Dout(dc::input, "PictureSequenceInput::SetCirclePictureArray, Radius=" << Radius);

    Npictures = _Npic;

    bool NormPos = (Radius<1);

    NewArray2d(PictureArray, Npictures, Target->N);

    if (Target->Nx >0 && Target->Ny > 0) {
//   int radius = min(Target->Nx, Target->Ny)/2;
        float dist;
        vector2d mp;
        float MaxDist ;

        if (NormPos) MaxDist = Radius;
        else MaxDist= Radius*Target->Nx;

        vector2d basis = vector2d(Target->Nx, Target->Ny);

        if (NormPos) basis = vector2d(1,1);

        Dout(dc::input, "MaxDist = " << MaxDist);

        for (i=0;i<Npictures;++i) {
            if (NormPos) mp = vector2d(_mpx, (float(i+1)/float(Npictures+1)));
            else mp = vector2d(_mpx, (3*Target->Ny/4 + Target->Ny*i/Npictures) % Target->Ny);

            mp.print();

            for (j=0;j<Target->N;++j) {
                dist = ((Target->Pos[j]) - mp).abs();

                if (dist < MaxDist) PictureArray[i][j] = 1;
                else  PictureArray[i][j] =Background;
            }
        }
    }
}


void PictureSequenceInput::SetTwoPointArray(float distance, float Radius)
{
    int i,j;
    double ix,iy;

    if (PictureArray != 0) {
        Dout(dc::input|dc::warning, "ERROR: PictureArray != 0 (picture array allready initialized)");
    }

    Dout(dc::input, "PictureSequenceInput::SetCirclePictureArray, Radius=" << Radius);

    Npictures = 2;

//     bool NormPos = (Radius<1);
    bool NormPos = true;

    NewArray2d(PictureArray, Npictures, Target->N);

    float* mpxList = new float[Npictures];

    // if (NormPos) ... // ToDo
    for (i=0;i<Npictures;++i) {
        mpxList[i] = 0.5 + 0.5*distance*(float(i)-(0.5*float(Npictures-1)))/(0.5*float(Npictures-1));
    }

    float mpy=0.5;

    if (Target->Nx >0 && Target->Ny > 0) {
//   int radius = min(Target->Nx, Target->Ny)/2;
        float dist;
        vector2d mp;
        float MaxDist ;

        if (NormPos) MaxDist = Radius;
        else MaxDist= Radius*Target->Nx;

        vector2d basis = vector2d(Target->Nx, Target->Ny);

        if (NormPos) basis = vector2d(1,1);

        Dout(dc::input, "MaxDist = " << MaxDist);

        for (i=0;i<Npictures;++i) {
            mp = vector2d(mpxList[i],mpy);
            mp.print();

            for (j=0;j<Target->N;++j) {
                dist = ((Target->Pos[j]) - mp).abs();

                if (dist < MaxDist) PictureArray[i][j] = 1;
                else  PictureArray[i][j] =0;
            }
        }
    }

    delete [] mpxList;
}



void PictureSequenceInput::SetLinearPictureArray(int _Npic, int _mpy, int _NumSeq, float Sigma)
{
    Dout(dc::input,  "SetLinearPictureArray___________________________");
    int i,j;
    double ix,iy;

    if (PictureArray != 0) Dout(dc::input,  "PictureArray != 0 (picture array allready initialized)");

    Npictures = _Npic;

    int SglObjSize = (Target->N / _NumSeq -2);

    if (SglObjSize <2) Dout(dc::input,  "ERROR: Target->N too small or _NumSeq too high");

    Dout(dc::input,  "MPY=" << _mpy << " Npic=" << Npictures << " Sigma=" << Sigma << "");

    NewArray2d(PictureArray, Npictures, Target->N);

    for (i=0;i<Npictures;++i) for (j=0;j<Target->N;++j) PictureArray[i][j]=0;

    if (Target->Nx >0 && Target->Ny > 0) {
        float dist;
        float mp;
        float MaxDist = SglObjSize/4;

        for (i=0;i<Npictures;++i) {
            mp = SglObjSize*i/Npictures;
//        Dout(dc::input,  " mp=" << mp);

            for (j=0;j<SglObjSize;++j) {
                if (j>mp) dist = min(j-mp, mp+SglObjSize-j);
                else dist = min(mp-j, j+SglObjSize-mp);

//      Dout(dc::input,  " " << dist);
                PictureArray[i][j+_mpy*SglObjSize] = gauss(dist/MaxDist, Sigma);
            }
        }
    }
}




void PictureSequenceInput::SetTestMode(float _StimDuration, float _Isi1Duration)
{
    StimDuration = int(_StimDuration/dt);
    Isi1Duration = int(_Isi1Duration/dt);
    StimHold = StimDuration;
    IsiHold = Isi1Duration;
    TestMode = true;
    mode = csimInputTest;
}

int PictureSequenceInput::proceede(int TotalTime)
{
    if (mSilent) return 0;
    
    int t = TotalTime % MacroTimeStep;

    switch (mode) {

        case csimInputTest:

            if (IsiHold > 1) {
                --IsiHold;
                isi=true;

            } else {
                isi=false;

                if (--StimHold <1) {
//      CurStimNr = 0; // getrandom(Npictures);
//      CurStimNr = getrandom(Npictures);
                    CurStimNr = (Npictures+CurStimNr +Direction) % Npictures;
                    StimHold = StimDuration;
                    IsiHold = Isi1Duration;
                    isi=true;
                }
            }

            break;

        case csimInputDefault:

            if (IsiHold > 1) {
                --IsiHold;
                isi=true;

            } else {
                isi=false;

                if (--StimHold <1) {
                    if ((NoJumpDuration >0) && (--NoJumpHold<1)) {
                        CurStimNr = getrandom(Npictures);
                        Direction = -1*Direction;
                        NoJumpHold = NoJumpDuration;
                        IsiHold = Isi1Duration;
                        isi=true;
                        Dout(dc::input,  "jump, NoJumpDuration=" << NoJumpDuration << "IsiDur=" << IsiHold << "");

                    } else {
                        CurStimNr = (Npictures+CurStimNr +Direction) % Npictures;
                        // + Npictures damit CurStimNr bei Direction==-1 nicht negativ werden kann.
                        IsiHold = Isi2Duration;
                        isi=true;
                        Dout(dc::input,  "Isi2Duration=" << IsiHold << "");
                    }

                    StimHold = StimDuration;
                }
            }

            break;

        case csimInputRandom:

            if (IsiHold > 1) {
                --IsiHold;
                isi=true;

            } else {
                isi=false;

                if (--StimHold <1) {
                    CurStimNr = getrandom(Npictures);
                    StimHold = StimDuration;
                    IsiHold = Isi1Duration;
                    isi=true;
                }
            }

            break;

        case csimInputRemote:
            CurStimNr = inpsync->GetRemoteStimNr();
            //Dout(dc::input,  " c " << CurStimNr); //REMOVE

            if ((CurStimNr==0) || (CurStimNr>Npictures)) isi=true;
            else {
                CurStimNr -=1;
                isi=false;
            }

            break;

        default:
            Dout(dc::input,  "ERROR: this shouldn't happen (PictureSequenceInput::proceede)");
    }

    if (!isi) {
        for (int i=0; i<Target->N;++i) {
            InputPointer[i] += mBackgroundStrength + Strength* PictureArray[CurStimNr][i];
        }

        RecordBuffer[t] = CurStimNr+1;

    } else RecordBuffer[t]=0;
}

int PictureSequenceInput::Show(int TotalTime)
{
    int t = TotalTime % MacroTimeStep;
    RecordBuffer[t] = CurStimNr;

    for (int i=0; i<Target->N;++i) InputPointer[i] += Strength* PictureArray[CurStimNr][i];
}


void PictureSequenceInput::Jump()
{
    CurStimNr = getrandom(Npictures);
    Direction = -1 + 2*getrandom(2);
}

void PictureSequenceInput::ClearPictureArray()
{
    if (PictureArray) {
        DeleteArray2d(PictureArray, Npictures);
        PictureArray=0;
    }
}

////////////////////////////////////////////

MultiSequenceInput::MultiSequenceInput(layer* tg, int Nseq, csimInputChannel InputNumber, float strength, int size, int _PtStart, int numpt, float ov, int dur): input(tg, InputNumber), NumSeq(Nseq)
{
    int SeqSize = int((1-ov)*size*numpt);

    for (int i=0;i<NumSeq;++i) {
        int PatternStart = (_PtStart + i*int(1.5*SeqSize)) % (tg->N - SeqSize);
        SequenceList.push_back(new PatternSequenceInput(tg, InputNumber, strength, size, PatternStart, numpt, ov, dur));
    }

    dt = tg->GetDt();

    CurInputNr=0;
    SwitchTime= int(200/dt);
    SwitchHold=0;
    MinStimTime=int(1000/dt);
    AddStimTime=int(2000/dt);
//     int StimTime=8000/dt;
    StimHold=MinStimTime + getrandom(AddStimTime);
    Dout(dc::input,  "NumSeq = " << NumSeq << "");
}

int MultiSequenceInput::proceede(int t)
{

    if (StimHold>0) StimHold--;
    else {
        SwitchHold=SwitchTime;
        StimHold=MinStimTime + getrandom(AddStimTime);
        CurInputNr = (CurInputNr + 1+ getrandom(NumSeq-1)) % NumSeq;
        SequenceList[CurInputNr]->Jump();
        SequenceList[CurInputNr]->RandomDir();
//   Dout(dc::input,  "SWITCH to "<< CurInputNr << "\n\n");
    }

    if (SwitchHold>0) SwitchHold--;
    else {
        SequenceList[CurInputNr]->proceede();
    }
}

//////////////////////////////////////////
MultiPictureSequenceInput::MultiPictureSequenceInput(layer* tg, csimInputChannel InputNumber, int Nseq, float strength, float _StimTime, float _IsiTime):  input(tg, InputNumber, strength), NumSeq(Nseq)
{
//     SetupPictureArrays(_StimDur);
    dt = tg->GetDt();

    CurInputNr=0;
    SwitchTime= int(200/dt);
    SwitchHold=0;
    MinStimTime=int(800/dt);
    AddStimTime=int(200/dt);
    StimTime = int(_StimTime/dt);
    StimHold=StimTime;
    IsiDuration=int(_IsiTime/dt);
    IsiHold=IsiDuration;
//     int StimTime=8000/dt;
    SeqHold=MinStimTime + getrandom(AddStimTime);
    Dout(dc::input,  "NumSeq = " << NumSeq << "");

}

int MultiPictureSequenceInput::SetupGaussPictureArrays(vector<vector<vector2d> >  mpList, float _StimDuration, float Sigma, float Cut)
{
    int i;
    int CurStimNumStart=0;
    PictureSequenceInput* pictmp;
    NumSeq = mpList.size();

    for (i=0;i<NumSeq;++i) {
        pictmp = new PictureSequenceInput(Target, InputNumber, Strength, _StimDuration);
        pictmp->SetGaussPictureArray(mpList[i], Sigma, Cut);
        SequenceList.push_back(pictmp);
        StimNumStart.push_back(CurStimNumStart);
        CurStimNumStart += mpList[i].size();
    }
}

int MultiPictureSequenceInput::SetupCirclePictureArrays(vector<vector<vector2d> >  mpList, float _StimDuration, float Radius)
{
    int i;
    int CurStimNumStart=0;
    PictureSequenceInput* pictmp;
    NumSeq = mpList.size();

    for (i=0;i<NumSeq;++i) {
        pictmp = new PictureSequenceInput(Target, InputNumber, Strength, _StimDuration);
        pictmp->SetCirclePictureArray(mpList[i], Radius);
        SequenceList.push_back(pictmp);
        StimNumStart.push_back(CurStimNumStart);
        CurStimNumStart += mpList[i].size();
    }
}


int MultiPictureSequenceInput::SetupPictureArrays(float _StimDuration)
{
    int i;
    float mpy;
    PictureSequenceInput* pictmp;
    int npic=10;
    int CurStimNumStart=0;
    float Sigma=0.2;

    for (i=0;i<NumSeq;++i) {
        mpy = 0.2 + 0.8*(float(i)/float(NumSeq));
        pictmp = new PictureSequenceInput(Target, InputNumber, Strength, _StimDuration);
        pictmp->SetPictureArray(npic, mpy, Sigma);
        SequenceList.push_back(pictmp);
        StimNumStart.push_back(CurStimNumStart);
        CurStimNumStart += npic;
    }

}

int MultiPictureSequenceInput::SetupLinearPictureArrays(float _StimDuration, float Sigma)
{
    int i;
    int  mpy;
    PictureSequenceInput* pictmp;
    int npic=100;
    int CurStimNumStart=0;

    for (i=0;i<NumSeq;++i) {
        mpy = i;
        pictmp = new PictureSequenceInput(Target, InputNumber, Strength, _StimDuration);
        pictmp->SetLinearPictureArray(npic, mpy, NumSeq, Sigma);
        SequenceList.push_back(pictmp);
        StimNumStart.push_back(CurStimNumStart);
        CurStimNumStart += npic;
    }

}

int MultiPictureSequenceInput::proceede(int TotalTime)
{
    int t = TotalTime % MacroTimeStep;

    switch (mode) {

        case csimInputRandom:

            if (StimHold>0) {
                StimHold--;
                isi=false;

            } else if (IsiHold > 1) {
                RecordBuffer[t] = 0;
                --IsiHold;
                isi=true;

            } else {
                isi=false;
                StimHold=StimTime;
                IsiHold=IsiDuration;
                CurInputNr = (CurInputNr + 1+ getrandom(NumSeq-1)) % NumSeq;
                SequenceList[CurInputNr]->Jump();
                SequenceList[CurInputNr]->RandomDir();
            }

            if (!isi) {
                SequenceList[CurInputNr]->Show();
                CurStimNr = StimNumStart[CurInputNr]
                            + SequenceList[CurInputNr]->GetCurStimNr();
                RecordBuffer[t] = CurStimNr+1;
            }

            break;

        case csimInputDefault:

        default:

            if (SeqHold>0) SeqHold--;
            else {
                SwitchHold=SwitchTime;
                SeqHold=MinStimTime + getrandom(AddStimTime);
                CurInputNr = (CurInputNr + 1+ getrandom(NumSeq-1)) % NumSeq;
                SequenceList[CurInputNr]->Jump();
                SequenceList[CurInputNr]->RandomDir();

                Dout(dc::input,  "SWITCH to "<< CurInputNr << "\n\n");
            }

            if (SwitchHold>0) SwitchHold--;
            else {
                SequenceList[CurInputNr]->proceede();
                RecordBuffer[t] = StimNumStart[CurInputNr]
                                  + SequenceList[CurInputNr]->GetCurStimNr();
            }

            break;
    }
}

void MultiPictureSequenceInput::SetTestMode(float _StimDuration, float _IsiDuration)
{
    for (vector<PictureSequenceInput*>::iterator it=SequenceList.begin(); it !=SequenceList.end(); ++it) {
        (*it)->SetTestMode(_StimDuration, _IsiDuration);
    }
}

void MultiPictureSequenceInput::Jump()
{
    for (vector<PictureSequenceInput*>::iterator it=SequenceList.begin(); it !=SequenceList.end(); ++it) {
        (*it)->Jump();
    }

    CurInputNr = (CurInputNr + 1+ getrandom(NumSeq-1)) % NumSeq;
}

/////////////////////////////////


//////////////////////////////
ObjMovieInput::ObjMovieInput(
    layer* tg, csimInputChannel InputNumber,
    ObjMovie* _Movie, int _FilterNr, float strength,
    float _StimDur, float _IsiDur)
        : input(tg, InputNumber, strength),
        MovieFile(_Movie),
        FilterNr(_FilterNr),
        StimDuration(int(_StimDur/dt)),
        TestMode(false),
        IsiDuration(int(_IsiDur/dt)),
        PositiveInput(true)
{
//      PictureArray = 0;
//      Npictures=0;

    // Timing parameters
    StimHold = StimDuration;
    IsiHold=0;
    Dout(dc::input,  "StimDuration is " << StimDuration << " TimeSteps");
    TestIsiDuration=int(_IsiDur/dt);
//      PtPointer=0;
//      TestMode=false;
    RandomNext = false;

    if (MovieFile == 0) Dout(dc::input,  "ERROR: No Movie-File!!");

    Data = MovieFile->GetFramePointer(FilterNr);

//      SwitchMaster = MovieFile->GetSwitchMaster();  //check wether or not I am the SwitchMaster (there can only be one!! first come first serve)
    SwitchMasterObj = MovieFile->GetSwitchMaster(this); //check wether or not I am the SwitchMaster (there can only be one!! first come first serve)

    if (SwitchMasterObj == 0) {
        SwitchMaster = true;

    } else {
        SwitchMaster = false;
    }

    FrameSize = MovieFile->GetFrameSize(FilterNr);

    if (FrameSize > Target->N) FrameSize=Target->N;
}



/** Setze neues MovieFile.
 * 
 * @param _Movie 
 * @param _FilterNr 
 */
void ObjMovieInput::SetMovieFile(ObjMovie* _Movie, int _FilterNr)
{
    
    if (_Movie == 0) {
        cerr << "ERROR: No Movie-File!!\n";
        return;
    }
    
    if (SwitchMaster && MovieFile) {
        MovieFile->ResetSwitchMaster();
    }
    
    MovieFile = _Movie;

    FilterNr = _FilterNr;

    // Timing parameters
    StimHold = StimDuration;
    IsiHold=0;
    Dout(dc::input,  "StimDuration is " << StimDuration << " TimeSteps");
    

    Data = MovieFile->GetFramePointer(FilterNr);
    
    // check wether or not I am the SwitchMaster 
    // (there can only be one!! first come first serve)
    SwitchMasterObj = MovieFile->GetSwitchMaster(this); 

    if (SwitchMasterObj == 0) {
        SwitchMaster = true;

    } else {
        SwitchMaster = false;
    }

    FrameSize = MovieFile->GetFrameSize(FilterNr);

    if (FrameSize > Target->N) FrameSize=Target->N;
}


void ObjMovieInput::InitializeTestMode(float _StimDuration, float _IsiDuration)
{
    Dout(dc::input,  "Setting ObjMovieInput-Test Mode");
    fflush(stdout);
    mode = csimInputTest;

    TestStimDuration= int(_StimDuration/dt);
    StimHold = TestStimDuration;
    TestIsiDuration=int(_IsiDuration/dt);
}


int ObjMovieInput::proceede(int TotalTime)
{
    int t = TotalTime % MacroTimeStep;

    if (SwitchMaster) {
        if (IsiHold > 1) {
            --IsiHold;
            isi=true;

        } else {
            isi=false;

            if (ResetToBeDone) {
                MainSimLoop->reset(t);
                ResetToBeDone=false;
            }

            if (--StimHold <1) {
                switch (mode) {

                    case csimInputTest: {
                        MovieFile->NextFrame();
                        isi=true;
                        StimHold = TestStimDuration;
                        IsiHold=TestIsiDuration;
                        ResetToBeDone=true;
                    }

                    break;

                    case csimInputDefault: {
                        MovieFile->NextFrame();
                        StimHold = StimDuration;
                        isi=true;
                        IsiHold=IsiDuration;
                    }

                    break;

                    case csimInputRandom: {
                        MovieFile->NextRandomFrame();
                        StimHold = StimDuration;
                        isi=true;
                        IsiHold=IsiDuration;
                    }

                    break;

                    default:
                        cerr << "ERROR: this shouldn't happen ObjMovieInput::proceede\n";
                }
            }
        }

    } else {
        isi = SwitchMasterObj->isi;
    }

    if (!isi) {
        if (PositiveInput) {
            for (int i=0; i<Target->N;++i) {
                float tmp = Strength*Data[i];

                if (tmp>0) {
                    InputPointer[i] += tmp;
                }
            }

        } else {
            for (int i=0; i<Target->N;++i) InputPointer[i] += Strength*Data[i];
        }
    }

    if (SwitchMaster) {
        if (!isi) RecordBuffer[t] = CurStimNr = MovieFile->GetFrameNumber()+1;
        else  RecordBuffer[t]=0;
    }
}

void ObjMovieInput::SetRandomNext(bool value)
{
    // RandomNext = value;
    SetMode(csimInputRandom);
    cerr << "ObjMovieInput::SetRandomNext(bool value) is depreciated\n";
    cerr << "use Input::SetMode instead\n";
}


void ObjMovieInput::SetStimDuration(int _stimdur)
{
    StimDuration = _stimdur;
}

void ObjMovieInput::SetTestMode(bool tm)
{
    TestMode = tm;

    if (tm) SetMode(csimInputTest);
    else  SetMode(csimInputDefault);
}

int ObjMovieInput::GetNFrames()
{
    return MovieFile->GetNFrames();
}

int ObjMovieInput::GetNStimuli()
{
    return MovieFile->GetNFrames();
}


///////////////////////////////////////////////

ScanObjMovieInput::ScanObjMovieInput(
    layer* tg, csimInputChannel InputNumber,
    ObjMovie* _Movie, int _FilterNr, float strength, float _StimDur,
    int _NXpara, int _NYpara, bool _XContinous, int _NoJumpHold, float _IsiDur, float _Isi2Dur, int _NoJumpDurationTest)
        : ObjMovieInput(tg, InputNumber, _Movie, _FilterNr, strength, _StimDur, _IsiDur),
        NXpara(_NXpara), NYpara(_NYpara), XContinous(_XContinous), direction(1),
        NoJumpDuration(_NoJumpHold), NoJumpHold(1), TestStimList(0)
        ,XCircle(true), XRandomChange(false) , YCircle(true), testiffirstrunever(0), dirchangecounter(0), testiffirsttestrunever(0),NoJumpDurationTest(_NoJumpDurationTest)
{
    Isi2Duration = int(_Isi2Dur/dt);
    IsiHold = IsiDuration;
}

int ScanObjMovieInput::WriteSimInfo(fstream &fw)
{
    stringstream sstr;
    sstr << "<NXPara value=\"" << NXpara << "\"/> \n";
    sstr << "<NYPara value=\"" << NYpara << "\"/> \n";
    sstr << "<StimTiming StimDur=\"" << StimDuration << "\" IsiDur=\"" << IsiDuration
    << "\" TestStimDur=\"" << TestStimDuration << "\" TestIsiDur=\"" << TestIsiDuration << "\" /> \n";
    input::WriteSimInfo(fw, sstr.str());
}

void ScanObjMovieInput::loadStimulusSequence(const char* FileName)
{
    mStimSequence.Load(FileName);
}


void ScanObjMovieInput::SetXCircle(bool value)
{
    XCircle = value;
}

void ScanObjMovieInput::SetXRandomChange(bool value)
{
    XRandomChange = value;
}

void ScanObjMovieInput::SetYCircle(bool value)
{
    YCircle = value;
}


int ScanObjMovieInput::proceede(int TotalTime)
{
    int t = TotalTime % MacroTimeStep;

    if (SwitchMaster) {
        if (IsiHold > 1) {  //InterStimulusInterval: kein Input
            --IsiHold;
            isi=true;

        } else {
            isi=false;

            if (ResetToBeDone) {
                MainSimLoop->reset(t);
                ResetToBeDone=false;
            }

            if (--StimHold <1)
                // show same stimulus for StimHold time intervals, then switch to next stimulus
            {
                switch (mode) {

                    case csimInputTest: {
                        ++TestIt;

                        if (TestIt == TestStimList->end()) {
                            TestIt = TestStimList->begin();
                        }

                        Xpara = (*TestIt).x;

                        Ypara = (*TestIt).y;
                        MovieFile->GotoFrameNr(Xpara + NXpara*Ypara);
                        StimHold = TestStimDuration;
                        IsiHold=TestIsiDuration;
                        isi=true;
                        ResetToBeDone=true;
                    }

                    break;

                    case csimInputDefault: {
                        if (RandomNext) MovieFile->NextRandomFrame();
                        else {
                            if (--NoJumpHold<1) {
                                NextRandom();
                                NoJumpHold=NoJumpDuration + getrandom(NoJumpDuration/2);
                                IsiHold=IsiDuration;
                                isi=true;

                            } else {
                                if (XContinous) NextX();
                                else NextY();

                                if (Isi2Duration > 0) {
                                    IsiHold=Isi2Duration;
                                    isi=true;
                                }
                            }

                            MovieFile->GotoFrameNr(Xpara + NXpara*Ypara);
                        }

                        StimHold = StimDuration;
                    }

                    break;

                    case csimInputSaccades: {
                        if (testiffirstrunever == 0) {
                            Xpara    /*   if (Xparacounter < 15)
{
     Xparacounter=+1;
     //  NextX();
     Xpara=5;
     ResetToBeDone=true;
     isi=false;
     IsiHold=0;
} else {
     Xparacounter = 0;
     //NextY();
     Xpara=1;
     ResetToBeDone=true;
     isi=false;
}
MovieFile->GotoFrameNr(Xpara + 15*Ypara) ;
StimHold = 1000;*/

                            /*    if (Xparacounter == NXpara){
                                     Xparacounter = 0;
                                     NextY();
                                     isi=false;
                                     ResetToBeDone=true;
                                } else {
                                     NextX();
                                     ResetToBeDone=true;
                                     isi=false;
                                     Xparacounter+=1;
                                }

                                MovieFile->GotoFrameNr(Xpara + NXpara*Ypara) ;
                                StimHold = 1000;*/
                            =0;
                            Ypara=0;
                            testiffirstrunever += 1;
                        }

                        if (--NoJumpHold<1) {
                            NextRandomX();//Saccade
                            NextY();
                            NextX();
                            NoJumpHold=NoJumpDuration;
                            + getrandom(NoJumpDuration/2);
                            IsiHold=IsiDuration;
                            isi=true;

                        } else {
                            NextRandomX();// Saccade
                            // NextX();

                            if (Isi2Duration > 0) {
                                IsiHold=Isi2Duration;
                                isi=true;
                            }
                        }

                        MovieFile->GotoFrameNr(Xpara + NXpara*Ypara);

                        StimHold = StimDuration;
                    }

                    break;

                    case csimInputSaccTest: {
                        if (--NoJumpHold<1) {
                            NextY();
                            NoJumpHold=NoJumpDurationTest;
                            IsiHold=0;
                            isi=false;
                            ResetToBeDone=true;

                        } else {
                            NextX();
                            IsiHold=0;
                            isi=false;
                            ResetToBeDone=true;
                        }

                        MovieFile->GotoFrameNr(Xpara + NXpara*Ypara) ;

                        StimHold = 1000 ;
                    }

                    break;

                    case csimInputSlideWinPic: {
                        if (++Xpara >= NXpara) {
                            Xpara=0;
                            Ypara = getrandom(NYpara);
                            IsiHold=IsiDuration;
                            isi=true;
                        }

                        MovieFile->GotoFrameNr(Xpara + NXpara*Ypara) ;

                        StimHold = StimDuration;
                    }

                    break;

                    case csimInputRandom: {
                        if (--NoJumpHold<1) {
                            NextRandom();
                            NoJumpHold=NoJumpDuration + getrandom(NoJumpDuration/2);
                            IsiHold=IsiDuration;
                            isi=true;

                        } else {
                            NextRandom();

                            if (Isi2Duration > 0) {
                                IsiHold=Isi2Duration;
                                isi=true;
                            }
                        }

                        MovieFile->GotoFrameNr(Xpara + NXpara*Ypara);

                        StimHold = StimDuration;
                    }
                    break;
                    
                    case csimInputPlayMovie: {
                        MovieFile->NextFrame();
                        StimHold = StimDuration;
                    }
                    break;

                    case csimInputSequence: {
                        
                        MovieFile->GotoFrameNr(mStimSequence.GetNextSeqElement());
                        StimHold = StimDuration;
                    }
                    break;
                    default:
                        cerr << "ERROR: this shouldn't happen ScanObjMovieInput::proceede, mode=" << mode << "\n";
                }
            }
        }

    } else {
        isi = SwitchMasterObj->isi;
    }

    if (!isi) {
        if (PositiveInput) {
            for (int i=0; i<Target->N;++i) {
                float tmp = Strength*Data[i];

                if (tmp>0) {
                    InputPointer[i] += tmp;
                }
            }

        } else {
            for (int i=0; i<Target->N;++i) InputPointer[i] += Strength*Data[i];
        }
    }

    if (SwitchMaster) {
        if (!isi) RecordBuffer[t] = CurStimNr = MovieFile->GetFrameNumber()+1;
        else  RecordBuffer[t]=0;
    }
}

int ScanObjMovieInput::NextX()
{
    if (!XRandomChange) {
        if (!XCircle) {
            if (Xpara==0) direction=1;

            if (Xpara==(NXpara-1)) direction=-1;

            Xpara += direction;

        } else {
            Xpara += direction;

            if (Xpara==NXpara) Xpara=0;

            if (Xpara<0) Xpara=NXpara-1;
        }
    }

    if (XRandomChange) {
        direction=1 - 2*getrandom(2);
        Xpara += direction;

        if (Xpara==NXpara) Xpara=0;

        if (Xpara<0) Xpara=NXpara-1;

    }
}

int ScanObjMovieInput::NextY()
{
    if (!YCircle) {
        if (Ypara==0) direction=1;

        if (Ypara==(NYpara-1)) direction=-1;

        Ypara += direction;

    } else {
        Ypara += direction;

        if (Ypara<0) Ypara=NYpara-1;

        if (Ypara==NYpara) Ypara=0;
    }
}

int ScanObjMovieInput::NextY_RandomDir()
{
    if (!YCircle) {
        direction = 1 - 2*getrandom(2);

        if (Ypara==0) direction=1;

        if (Ypara==(NYpara-1)) direction=-1;

        Ypara += direction;

        /*} else {
                   // direction=1 - 2*getrandom(2);//1*direction;
            if (dirchangecounter==0){
          //  Ypara =0;
            Ypara=0;
            //direction=-1*direction;
          dirchangecounter=dirchangecounter+1;
            }else {
            Ypara=1;
            dirchangecounter=0;
            }
                  // Ypara += direction;
            if (Ypara<0) Ypara=NYpara-1;
            if (Ypara==NYpara) Ypara=0;
             } */

    } else {
        /* if (dirchangecounter==0){
        direction=1;
        dirchangecounter=dirchangecounter+1;
         }
         if (dirchangecounter==1){
        direction=1;
        dirchangecounter+=1;
         }
         if (dirchangecounter==2){
        direction=-1;
        dirchangecounter=0;
         }*/
        direction = 1;//-2*getrandom(2);
        Ypara += direction;

        if (Ypara<0) Ypara=NYpara-1;

        if (Ypara==NYpara) Ypara=0;
    }
}



int ScanObjMovieInput::NextRandom()
{
    Xpara = getrandom(NXpara);
    Ypara = getrandom(NYpara);
    direction = 1 - 2*getrandom(2);
}

int ScanObjMovieInput::NextRandomX()
{
    //Xpara=0;
    Xpara = getrandom(NXpara);
    // direction = 1;
//   direction = 1 - 2*getrandom(2);
}

int ScanObjMovieInput::NextObjpos()
{
    Ypara=Ypara;

    if (Ypara<0) Ypara=NYpara-1;

    if (Ypara==NYpara) Ypara=0;

}

int ScanObjMovieInput::NextJitterX()
{
    direction = 1 - 2*getrandom(3);
    Xpara +=direction;
}


int ScanObjMovieInput::NextRandomObjpos()
{
    Ypara=getrandom(NYpara);
    //if (Ypara<0) Ypara=NYpara-1;
    //if (Ypara==NYpara) Ypara=0;

}


void ScanObjMovieInput::InitializeTestMode(XYpairList* StimList, float _StimDuration, float _IsiDuration)
{
    Dout(dc::input,  "Setting ScanObjMovieInput-Test Mode");
    TestStimList = new XYpairList(*StimList);
//     TestStimList = StimList;
    TestMode = true;
    mode = csimInputTest;

    TestStimDuration= int(_StimDuration/dt);
    StimHold = TestStimDuration;
    TestIsiDuration=int(_IsiDuration/dt);
    
    for (TestIt=TestStimList->begin(); TestIt != TestStimList->end(); ++TestIt) {
        Dout(dc::input, "X=" << (*TestIt).x << " Y=" << (*TestIt).y);
    }

    TestIt = TestStimList->begin();
}

ResponseMap* ScanObjMovieInput::GetTestStimMap()
{
    ResponseMap* tmp = new ResponseMap;

    if (TestStimList != 0) {
        vector<XYpair>::iterator it;
        int counter=0;

        for (it=TestStimList->begin(); it != TestStimList->end(); ++it) {
            (*tmp)[1+ (*it).x + NXpara*(*it).y] = counter++;
        }

        return tmp;

    } else return 0;
}

void ScanObjMovieInput::SetMode(InputMode _mode)
{
    input::SetMode(_mode);

    if (mode == csimInputTest) {
        TestIt = TestStimList->begin();
        ResetToBeDone=true;
        IsiHold = 0;
        StimHold = TestStimDuration;
        Xpara = (*TestIt).x;
        Ypara = (*TestIt).y;
        MovieFile->GotoFrameNr(Xpara + NXpara*Ypara);
    }

    if (mode == csimInputDefault) {
        NextRandom();
        IsiHold = 0;
        NoJumpHold=NoJumpDuration;
        StimHold = StimDuration;
    }

    if (mode == csimInputSaccTest) {
        Xpara=0;
        Ypara=0;
        IsiHold=0;
        isi=true;
        StimHold = 0;
        NoJumpHold=NoJumpDurationTest;
        ResetToBeDone=true;
        MovieFile->GotoFrameNr(0);

        //NoJumpHold=NoJumpDurationTest;
        // IsiHold=Isi2Duration;
    }


}


//////////////////////////////////////


SequenceObjMovieInput::SequenceObjMovieInput(
    layer* tg, csimInputChannel InputNumber,
    ObjMovie* _Movie,StimulusSequence* _seq,
    int _FilterNr, float strength, float _StimDur,
    int _NoJumpHold)
        : ObjMovieInput(tg, InputNumber, _Movie, _FilterNr, strength, _StimDur),
        direction(1),NoJumpDuration(_NoJumpHold), NoJumpHold(1)
{
    StimSeq = _seq;
}

int SequenceObjMovieInput::proceede(int TotalTime)
{
    int t = TotalTime % MacroTimeStep;
    int NextStimNr=0;

    if (SwitchMaster && (--StimHold <1)) {
        if (TestMode) {
//         ++TestIt;
//         if (TestIt == TestStimList->end()) TestIt = TestStimList->begin();
//         Xpara = (*TestIt).x;
//         Ypara = (*TestIt).y;
            MovieFile->GotoFrameNr(0);
            StimHold = TestStimDuration;

        } else {
            if (RandomNext) MovieFile->NextRandomFrame();
            else {
                if (--NoJumpHold<1) {
                    NextStimNr=StimSeq->GetNextRandomElement(gslr);
                    NoJumpHold=NoJumpDuration + getrandom(NoJumpDuration/2);

                } else {
                    NextStimNr=StimSeq->GetNextSeqElement();
                }

                MovieFile->GotoFrameNr(NextStimNr);
            }

            StimHold = StimDuration;
        }
    }

    for (int i=0; i<Target->N;++i) InputPointer[i] += Strength*Data[i];

    if (SwitchMaster) {
        RecordBuffer[t] = CurStimNr = MovieFile->GetFrameNumber();
    }
}

// int SequenceObjMovieInput::NextX()
// {
//      Xpara = (Xpara + NXpara + direction) % NXpara;
// }

// int SequenceObjMovieInput::NextY()
// {
//      Ypara = (Ypara + NYpara + direction) % NYpara;
// }

// int SequenceObjMovieInput::NextRandom()
// {
//      Xpara = getrandom(NXpara);
//      Ypara = getrandom(NYpara);
//      direction = 1 - 2*getrandom(2);
// }

// void SequenceObjMovieInput::InitializeTestMode(XYpairList* StimList, float _StimDuration, float _IsiDuration)
// {
//      Dout(dc::input,  "Setting SequenceObjMovieInput-Test Mode"); fflush(stdout);
//      TestStimList = StimList;
//      TestMode = true;
//      TestStimDuration= int(_StimDuration/dt);
//      for (TestIt=StimList->begin(); TestIt != StimList->end(); ++TestIt)
//    Dout(dc::input,  "X=" << (*TestIt).x << " Y=" << (*TestIt).y << "");
//      TestIt = StimList->begin();
// }

// ResponseMap* SequenceObjMovieInput::GetTestStimMap()
// {
//      ResponseMap* tmp = new ResponseMap;
//      if (TestStimList != 0)
//      {
//    vector<XYpair>::iterator it;
//    int counter=0;
//    for (it=TestStimList->begin(); it != TestStimList->end(); ++it)
//    {
//         (*tmp)[1+ (*it).x + NXpara* (*it).y] = counter++;
//    }
//    return tmp;
//      } else return 0;
// }

////////

VarSequenceInput::VarSequenceInput(layer* tg,csimInputChannel InputNumber): input(tg,InputNumber)
{
    fflush(stdout);
    Pictures=new vector<vector<float> >(0);
}

VarSequenceInput::~VarSequenceInput()
{
    delete Pictures;

    for (vector<int*>::const_iterator it=Sequence.begin();it!=Sequence.end();it++)
        delete[] *it;
}

void VarSequenceInput::addPicture(vector<float>& newPic)
{
    if (newPic.size()==Target->N) {
        cout<<"Added Picture to VarSequenceInput\n";
        Pictures->push_back(newPic);
    }
}

void VarSequenceInput::changePicture(int PicNumb,vector<float>& newPic)
{
    if (newPic.size()==Target->N) {
        cout<<"Changed Picture by VarSequenceInput.\n";

        for (int i=0;i<Target->N;i++) {
            (*Pictures)[PicNumb][i]=newPic[i];
        }
    }
}

void VarSequenceInput::addSequence(int seqDur,int picNumb)
{
    cout<<"Added Sequence to VarSequenceInput with Dur="<<seqDur<<" pic="<<picNumb<<"\n";
    int* temp=new int[2];
    temp[0]=seqDur;
    temp[1]=picNumb;
    Sequence.push_back(temp);
}

bool VarSequenceInput::changeSequence(int index,int seqDur,int picNumb)
{
    if (index<Sequence.size() && seqDur>0) {
        Sequence[index][0]=seqDur;
        Sequence[index][1]=picNumb;
        return true;
    }

    return false;
}

void VarSequenceInput::setSequenceIterator()
{
    cout<<"Sequenceiterator for VarSequenceInput was set\n";
    SequenceIterator=Sequence.begin();
    steps=(*SequenceIterator)[0];
}

int VarSequenceInput::proceede(int TotalTime)
{
    //cout<<"Anfang von proceede VarSequenceInput\n"; fflush(stdout);
    int pic=(*SequenceIterator)[1];
    //printSequences();
    //cout<<pic<<"   "<<steps<<"\n";

    for (int i=0;i<Target->N;i++) InputPointer[i]+=Pictures[0][pic][i];

    //cout<<"    Ende von setInput\n"; fflush(stdout);
    steps--;

    if (steps<1) {
        ++SequenceIterator;

        if (SequenceIterator==Sequence.end()) SequenceIterator=Sequence.begin();

        steps=(*SequenceIterator)[0];
    }

    //cout<<"Ende von proceede VarSequenceInput\n"; fflush(stdout);
}

void VarSequenceInput::printSequences()
{
    for (vector<int*>::const_iterator it=Sequence.begin();it!=Sequence.end();it++) {
        cout<<"dur="<<(*it)[0]<<"   pic="<<(*it)[1]<<"\n";
    }
}

//////////////////////////////////////////

SpikeTrainInput::SpikeTrainInput(layer* tg, csimInputChannel InputNumber, float strength, float _SpikeFreq, float _SpikeWidth): input(tg, InputNumber, strength), SpikeFrequency(_SpikeFreq), Picture(0), SyncStimNr(0)
{
    SpikeDuration = int(_SpikeWidth/dt);
    SpikeHold = 0;
    InterSpikeHold=0;
    SetSpikeFrequency(_SpikeFreq);
    SetPictureCircle();
}

SpikeTrainInput::~SpikeTrainInput()
{
    if (Picture != 0) delete [] Picture;

    if (SyncStimNr) delete [] SyncStimNr;
}


void SpikeTrainInput::SetPictureCircle()
{
    int j;
    float Radius=0.2;
    Picture = new float [Target->N];

    if (Target->Nx >0 && Target->Ny > 0) {
        float dist;
        vector2d mp(0.5, 0.5);
        vector2d basis = vector2d(Target->Nx, Target->Ny);

        if (Target->NormPos) basis = vector2d(1,1);

        Dout(dc::input,  "NormPos=" << Target->NormPos << "Radius=" << Radius <<  "");

        Dout(dc::input,  "MPx=" << mp.x << "MPy=" << mp.y << "");

        for (j=0;j<Target->N;++j) {
            dist = (Target->Pos[j]).CyclicDistance(mp, basis);

            if (dist < Radius) Picture[j] = 1;
            else Picture[j] =0;
        }
    }
}

void SpikeTrainInput::SetPictureAll()
{
    int j;
    float Radius=0.2;
    Picture = new float [Target->N];

    for (int i=0; i<Target->N;++i) {
        Picture[i]=1;
    }
}


void SpikeTrainInput::SetSpikeFrequency(float _SpikeFreq)
{
    InterSpikeDuration=int(1000./(_SpikeFreq*dt))-SpikeDuration;
}

int SpikeTrainInput::proceede(int TotalTime)
{
    int t = TotalTime % MacroTimeStep;

    switch (mode) {

        case csimInputDefault:

            if (InterSpikeHold > 0) {
                --InterSpikeHold;
                isi=true;

            } else if (SpikeHold > 0) {
                --SpikeHold;
                isi=false;

            } else {
                InterSpikeHold=InterSpikeDuration;
                SpikeHold = SpikeDuration;
                isi=true;
            }

            break;

        case csimInputRemote:
            SyncStimNr[t+DelayDuration]=inpsync->GetRemoteStimNr();

            if (SyncStimNr[t] == 0) isi=true;
            else isi=false;

            break;

        default:
            Dout(dc::input,  "ERROR: this shouldn't happen");
    }

    if (!isi) {
        for (int i=0; i<Target->N;++i) InputPointer[i] += Strength* Picture[i];

        RecordBuffer[t] = CurStimNr+1;

    } else RecordBuffer[t] = 0;
}


int SpikeTrainInput::SetInputSync(InputSynchronizer* _inpsync, float _delay)
{
    input::SetInputSync(_inpsync);
    DelayDuration = int(_delay/dt);
    SyncStimNr = new int [MacroTimeStep + DelayDuration + 1];

    for (int i=0;i<MacroTimeStep + DelayDuration + 1; ++i) SyncStimNr[i]=0;
}

int SpikeTrainInput::prepare(int step)
{
    input::prepare(step);

    if (SyncStimNr) {
        for (int i=0; i<DelayDuration;++i) SyncStimNr[i] = SyncStimNr[MacroTimeStep-1+i];
    }
}

///////////////////////////

ShiftObjMovieInput::ShiftObjMovieInput(layer* tg, csimInputChannel InputNumber, ObjMovie* _Movie, int FilterNr, float strength, float _StimDur, float _IsiDur): ObjMovieInput(tg, InputNumber, _Movie, FilterNr, strength, _StimDur, _IsiDur)

{
    Data = MovieFile->GetShiftedFramePointer(FilterNr);
    Dout(dc::input,  "FilterNr=" << FilterNr << "");
}

int ShiftObjMovieInput::proceede(int TotalTime)
{
    int t = TotalTime % MacroTimeStep;

    if (SwitchMaster) {
        if (IsiHold > 1) {
            --IsiHold;
            isi=true;

        } else {
            isi=false;

            if (ResetToBeDone) {
                MainSimLoop->reset(t);
                ResetToBeDone=false;
            }

            if (--StimHold <1) {
                switch (mode) {

                    case csimInputTest: {
                        MovieFile->NextFrame();
                        isi=true;
                        StimHold = TestStimDuration;
                        IsiHold=TestIsiDuration;
                        ResetToBeDone=true;
                    }

                    break;

                    case csimInputDefault: {
                        MovieFile->NextFrame();
                        StimHold = StimDuration;
                        isi=true;
                        IsiHold=IsiDuration;
                    }

                    break;

                    case csimInputRandom: {
                        MovieFile->NextRandomFrame();
                        StimHold = StimDuration;
                        isi=true;
                        IsiHold=IsiDuration;
                    }

                    break;

                    default:
                        cerr << "ERROR: this shouldn't happen\n";
                }
            }
        }

    } else {
        isi = SwitchMasterObj->isi;
    }

    if (!isi) {
        MovieFile->SetFrameShift(0.3, 0.1);

        if (PositiveInput) {
            for (int i=0; i<Target->N;++i) {
                float tmp = Strength*Data[i];

                if (tmp>0) {
                    InputPointer[i] += tmp;
                }
            }

        } else {
            for (int i=0; i<Target->N;++i) InputPointer[i] += Strength*Data[i];
        }
    }

    if (SwitchMaster) {
        if (!isi) RecordBuffer[t] = CurStimNr = MovieFile->GetFrameNumber()+1;
        else  RecordBuffer[t]=0;
    }
}

/** Returns Circle picture as one dimensional vector with size SizeX*SizeY
 *
 * @param SizeX
 * @param SizeY
 * @param MpX
 * @param MpY
 * @param Radius
 * @param Amplitude
 * @param Background
 * @return
 */
vector<float> CirclePicture(
    int SizeX,
    int SizeY,
    float MpX,
    float MpY,
    float Radius,
    float Amplitude,
    float Background,
    bool NormPos)
{
    // initialize picture with Background value
    vector<float> Picture(SizeX*SizeY, Background);
    float dist;
    vector2d mp(MpX, MpY);
    vector2d basis = vector2d(SizeX, SizeY);

    if (NormPos) {
        basis = vector2d(1,1);
    }

    vector2d Pos;

    for (int PosY=0; PosY<SizeY;++PosY) {
        for (int PosX=0; PosX<SizeX;++PosX) {
            if (NormPos) {
                Pos=vector2d(float(PosX)/SizeX, float(PosY)/SizeY);

            } else {
                Pos=vector2d(PosX,PosY);
            }

            dist = Pos.CyclicDistance(mp, basis);

            if (dist <= Radius) {
                Picture[PosX+SizeX*PosY] = Amplitude;
            }
        }
    }

    return Picture;
}