'this script makes spikes from data channels bigger (for figures).  it starts from offset seconds after the trigger times 
' and removes points% number of points, and replaces them with a the factor * average of the original spike
' it creates a trigger channel in which the spike events of the spike to bigify must be contained.

var dataChan%;
var trigChan%;
var offset:=0;
var points%:=4;
var ret%;
var time;
'var origin[85];
var bin;
var v1%, v2%;
v2%:=View();
var r,rr,makesmall:=1,makebig:=2,yy;


var trigmem%:=-1;
var evint:=0.005;
var test1,test2;

ToolbarClear();
ToolbarSet(1, "trigger", trigger%);
ToolbarSet(2, "Stop", stop%);

ToolbarSet(3, "bigify", artifact%);
repeat
  Toolbar("",1023);
until 0;
Halt;


func stop%()
halt;
end; 

func artifact%()
'PrintLog(View(v1%).[], " ", v2%);
'XRange(0,Maxtime());
'Optimise(-1);

FrontView(v2%);

DlgCreate("bigify spikes");
DlgChan(1,"Select waveform data channel",1);
DlgChan(2,"Select trigger channel",2+4+8);
DlgReal(3,"by what factor do you want to bigify your spikes?",-1000,1000); 'its not really correct, only the AVERAGE is multiplied
DlgReal(4,"by what factor do you want to smallerize all other spikes?",-1000,1000); 'this is a correct calculation

CursorDelete(-1);
CursorNew(XLow()+1);     'macht neuen Cursor an Stelle links im Fenster + 1 sec
CursorNew(Xhigh()-1);
Interact("set Cursors for region to average ",1);

r:=Cursor(1);
rr:=Cursor(2);

ret%:=DlgShow(dataChan%, trigChan%,makebig,makesmall);

makesmall:=1/makesmall; 'setzt Faktor zum Verkleinern richtig

if ret%>0 then
  AVERAGE();
endif;
if ret%>0 then
  FrontView(v2%);
  DelArt%(dataChan%,trigChan%,0,Maxtime(),offset,points%);
endif;
end;


func DelArt%(dataCh%, trigCh%, locSTime, locETime, offset, points%)
var mem%;

var arr[points%];



var list%[33];
var title$,newtitle$;
var yesno$;
bin:=Binsize(dataCh%);
title$:=ChanTitle$(dataCh%);
newtitle$:=title$+"_KILL";

mem%:=MemChan(1,0,bin);
ChanScale(mem%,ChanScale(dataCh%));
ChanTitle$(mem%, newtitle$);


time:=CopyChan(dataCh%, mem%, locSTime, locETime);
   repeat
     time:=NextTime(trigCh%, time);
     'PrintLog(time);
  
     if time>0 and time<locETime then 
       MakeSlope%(arr[], ChanValue(mem%, time-offset), ChanValue(mem%, time-offset+points%*bin));
       MemSetItem(mem%, 0, time-offset, arr[]);
		 
     endif;
   until time<0 or time>locETime;
ChanList(list%[], 128);

if list%[0]>0 then

	yesno$:=input$("Would you like to copy filtered datums to a permanent channel (y/n)","y",1,"y-n");
  		if yesno$="y" then 
			MemSave(mem%, list%[1]);
			ChanDelete(mem%);
  			ChanShow(list%[1]);
		else
			ChanShow(mem%);
		endif;

endif;

draw(test1,test2-test1);
end;

func MakeSlope%(arr[], sVal, eVal); 'add AVERAGE to Original
var len%;
var inc;
var curs;
var k;
var value;
var origin[points%];
var avg[points%];
len%:=Len(arr[]);
inc:=(eVal-sVal)/len%;

ArrAdd(avg[],View(v1%).[]); 'hier wird der Average in array avg[] geschrieben
ArrMul(avg[],makebig); 'und mit dem Faktor zum Groessermachen multipliziert

ChanData(dataChan%, origin[], time-offset, time-offset+points%*bin); 'fuellt array "origin" mit Originalkanaldateien

ArrAdd(origin[],avg[]); 'hier wird dann der Average dazugezaehlt
ArrConst(arr[],origin[]); 'und das array origin[] in das array arr[] kopiert. eigentlich unnoetig
return 1;
end;

func CopyChan(source%, dest%, locSTime, locETime)       'COPIES Original CHANNEL to Memchan with smallerize factor
var arrSize%;
var pts%;
var locFTime;
arrSize%:=Round((locETime-locSTime)/Binsize(source%))+1;
var arr[arrSize%];

pts%:=ChanData(source%, arr[], locSTime, locETime, locFTime);

if makesmall<>1 then 'falls Faktor zum Verkleinern angegeben wurde wird das array mit des ganzen Kanals hier mit 1/faktor multipliziert
		arrMul(arr[],makesmall);
endif;


MemSetItem(dest%, 0, locFTime, arr[:pts%]);
return locFTime;
end;



func AVERAGE()

'dataChan%:=4;
var start;
bin:=Binsize(dataChan%);
start:=nexttime(trigChan%,0);
draw(start-0.5,1);
CursorDelete(-1);       'loescht alle vertikalen Cursor
CursorNew(XLow()+0.05);     'macht neuen Cursor an Stelle links im Fenster + 1 sec
CursorNew(Xhigh()-0.05);
interact("set Cursors to begin and end of artifact", 1023);
offset:=start-Cursor(1);
points%:=(Cursor(2)-Cursor(1))/bin;

PrintLog(offset, " ", bin, " ", points%);

v1%:=SetAverage(dataChan%,points%,offset,trigChan%,1);
Process(r,rr);



'v1% := FileOpen("",4);
WindowVisible(1);
end;


func trigger%()
'---------------------------------------
'if trigmem% > 0 then ChanDelete(trigmem%); endif; 'loescht den eventch 1 usw...

DlgCreate("Set Trigger Channel");
DlgChan(1,"Select waveform data channel",1);

DlgShow(dataChan%);



trigmem%:=MemChan(3,0);
CursorDelete(-1);       'loescht alle vertikalen Cursor
CursorNew(XLow()+1);     'macht neuen Cursor an Stelle links im Fenster + 1 sec
CursorNew(Xhigh()-1);
Interact("Place the cursors around the region to be analysed...", 1023); 'die 1023 erlaubt dem User alles am Fenster zu verstellen
CursorRenumber(); 'renumbered cursor -> linker cursor wird cursor 1
HCursorDelete(1);HCursorNew(dataChan%);  'neuer horizontaler cUrsor
Interact("Hcursor positionieren", 1023);

evint:=evint*1000;
evint:=Input("Minimum delay to next triggerpoint in ms?", evint, 0, 5000);
evint:=evint/1000;

'trigmem%:=MemChan(2);
MemImport(trigmem%, dataChan%, Cursor(1), Cursor(2), 2, evint, HCursor(1)); 'schreib in Memchan
ChanShow(trigmem%);
'FrontView(View());Draw(0, 10);
test1:=Cursor(1);  '2 variablen , die sich die cursorpositionen merken
test2:=Cursor(2);
return;
end;