%Linsenprogramm
%Programm zur simulation von Abbildungen durch Linsen 
%nach den Regeln der Geometr. Optik
%
%Applikationssoftware für Fortgeschrittene
%
%
%Autoren: Edegger Bernhard, Thünauer Roland
%Version 1.0 Beta


function  varargout=linsen(flag,val)

global text_ed_lins_x text_ed_lins_f text_ed_lins_r vignett
global text_ed_g text_ed_b text_ed_yb text_ed_yg text_geg text_linsen
global a aktivl bl gg aktivg xxx
global figure_1 pat 
global axes_1 axes_2 lg axes_3 axes_4
global xlim ylim vig gd 
global menu11 menu12 menu1 gd_line
global lins geg b hah bl gg
global slider_l_text_1c slider_l s slider_geg_text_1c slider_geg slider_b_text_1c slider_b
global fontunits fontsize textshift textshift1 zb_line
global ed_lins_x ed_lins_f ed_lins_r ed_g ed_yg ed_b ed_yb
global gegenstand brenn2 brenn1 linse linse_or linse_ur bild

if nargin == 0
   
   clear all
   global text_ed_lins_x text_ed_lins_f text_ed_lins_r vignett
	global text_ed_g text_ed_b text_ed_yb text_ed_yg text_geg text_linsen
	global a aktivl bl gg aktivg xxx zb_line
	global menu11 menu12 menu1 lg axes_3
	global figure_1 vig gd gd_line
	global axes_1 axes_2 axes_4 
	global xlim ylim pat
	global lins geg b hah gg bl
	global slider_l_text_1c slider_l s slider_geg_text_1c slider_geg slider_b_text_1c slider_b
	global fontunits fontsize textshift textshift1 
	global ed_lins_x ed_lins_f ed_lins_r ed_g ed_yg ed_b ed_yb
   global gegenstand brenn2 brenn1 linse linse_or linse_ur bild

%Einstellungen für Text   
   flag = 'init';
   textshift = 0.03;
   fontunits = 'normalized';
   fontsize  = 0.02;
   %Anzahl der Linsen und Blenden
   a=1;
   %Anzahl der Linsen bl
   bl=1;
   %Anzahl der Gegenstände gg
   gg=1;
   hah=a-bl;
   %Anzahl der Blenden hah
   aktivg=1;
   aktivl=1;
%Erzeugen der Matrix mit den Linsen/Blendendaten
   f = 50;
   r=50;
   g=2*f;
   yg=10;
   lins=[0,r,f];
   lins=repmat(lins,a,1);
   %Verschiedengroße Anfangskoordinaten erzeugen
   lins(:,1)=lins(:,1)+((0:(a-1))*5)';
   %Blendenbrennweite = 0
   if bl<a
     lins(bl+1:a,3)=0;
   end
%Erzeugen der Matrix für Gegenstandsdaten
   geg=[lins(aktivl,1)-g,lins(aktivl,1)-g,0,yg];
   
   geg=repmat(geg,gg,1);
   %Verschiedengroße Anfangskoordinaten erzeugen
   geg(:,1:2)=geg(:,1:2)+repmat(((0:(gg-1))*5),2,1)';
%Bildkoordinaten
   b=zeros(gg,4);
%Einstellung ob mit Vignettierung (vig=1)
%oder mit geometr Darstellung (gd=1)
   vig=0;
   gd=0;
end


switch flag
   
case 'init'
  
%Aufruf der Initialisierungsprogramme, Namen sprechen für sich
   linsen('init_fig');
   linsen('init_axes_1');
   linsen('init_axes_2');
   linsen('init_axes_vig');
   linsen('init_ed_g');
   linsen('init_ed_yg');
   linsen('init_ed_b');
   linsen('init_ed_yb');
   linsen('init_ed_lins_f');
   linsen('init_ed_lins_r');
   linsen('init_ed_lins_x');
   linsen('init_gegenstand');
   linsen('init_linse');
   linsen('init_brenn');
   linsen('init_bild');
   linsen('init_slider_l');
   linsen('init_slider_b');
   linsen('init_slider_geg');
   linsen('init_menu');
   linsen('rechnung');
   
%Grundeinstellungen     
case 'init_fig'
    %Bildschirmgröße einlesen
	s=get(0,'Screensize');
	s=[s(1)+50,s(2)+100,s(3)-100,s(4)-200];
	%Position der Figure einstellen
   set(0,'DefaultFigurePosition',s);
   clf;
   figure_1 = figure(1);
   set(figure_1,'Units','normalized');
    
case 'init_axes_1'
      
	axes_1 = axes( ...
	'Parent',figure_1, ...
   'Position',[0 0 1 1], ...
   'Units','normalized', ...
	'Visible','off' ...
	);
  
case 'init_axes_2'
%Limits berechnen    
	xlim=[-200,200];
	y=(s(4)*0.5)/(s(3)*0.8)*400;
	ylim=[-y/2,y/2];
%Axes_2 zeichnen
   axes_2 = axes(...
	'Parent',figure_1, ...
	'Units','normalized', ...
	'Position',[0.1 0.35 0.8 0.5], ...
	'XLim',xlim, ...
	'YLim',ylim, ...
	'Box','on', ...
	'Visible','on', ...
	'XTick',[xlim(1):20:xlim(2)],...
	'YTick',[ylim(1)-(mod(ylim(1),20)):20:ylim(2)+mod(ylim(2),20)]...
	); 
%Figure betiteln
   tit1=title('Abbildungen','FontSize',30,'FontWeight','bold');
%Opt. Hauptachse (OHA) zeichnen
	OHA=line([xlim(1),xlim(2)],[0,0],'Color','black','LineStyle','--');

%Bildeinstellungen, Bild zeichnen
case 'init_ed_b'               
   
   for x=1:gg
%Editor für Bildposition
	position   = [0.25 0.15 0.05 0.03];
   xval       = b(gg,1);
   ed_b(x) = uicontrol( ...
       'Parent',figure_1, ...
       'Style','edit', ...
       'String',num2str(xval),...
       'Units','normalized', ...
       'Position',position, ...
       'Visible','off', ...
       'Callback','linsen ed_b' ...
       );
  
%Text über Editor   
   textpos  = [position(1)+position(3)/2,position(2)+position(4)/2+textshift];
   text_ed_b(x) = text( ...
       'Position',textpos, ...
       'Parent',axes_1, ...
       'FontUnits',fontunits, ...
       'FontSize',fontsize, ...
       'HorizontalAlignment','center', ...
       'Visible','off', ...
       'VerticalAlignment','middle', ...
       'String','Bildposition' ...
       );
    end
    
    set(text_ed_b(aktivg),'Visible','on');
    set(ed_b(aktivg),'Visible','on');
    
case 'init_ed_yb'               
   
   
   for x=1:gg

	position   = [0.25 0.05 0.05 0.03];
   xval       = b(x,4);
%Editor für Bildgröße
   ed_yb(x) = uicontrol( ...
       'Parent',figure_1, ...
       'Style','edit', ...
       'String',num2str(xval),...
       'Units','normalized', ...
       'Position',position, ...
       'Visible','off', ...
       'Callback','linsen ed_yb' ...
       );

%text über Editor  
   textpos  = [position(1)+position(3)/2,position(2)+position(4)/2+textshift];
   text_ed_yb(x) = text( ...
       'Position',textpos, ...
       'Parent',axes_1, ...
       'FontUnits',fontunits, ...
       'FontSize',fontsize, ...
       'Visible','off', ...
       'HorizontalAlignment','center', ...
       'VerticalAlignment','middle', ...
       'String','Bildhöhe' ...
       );
  	end
     
   set(text_ed_yb(aktivg),'Visible','on');
   set(ed_yb(aktivg),'Visible','on');
	 
    
case 'init_bild'
   
   for x=1:gg
%Bild zeichnen
   bild(x)=line(...
      'Parent',axes_2, ...
		'ButtonDownFcn','linsen hit_gegenstand',...
		'EraseMode','xor', ...
      'Color','yellow',...
      'LineWidth',2,...
		'XData',[b(x,1) b(x,2)], ...
		'YData',[b(x,3) b(x,4)] ...
      );
   end
bild=bild(1:gg);

case 'ed_b'
%Callbackroutine für Bildpos.-Editor   
   v = str2num(get(ed_b(aktivg),'String'));
   b(aktivg,1)=min([max([v,xlim(1)]),xlim(2)]);
   b(aktivg,2)=geg(aktivg,1);
   set(bild(aktivg),'XData',[b(aktivg,1) b(aktivg,2)]);
   set(ed_b(aktivg),'String',num2str(b(aktivg,1)));
   
   
case 'ed_yb'
%Callbackroutine für Bildhöhen-Editor    
   v = str2num(get(ed_yb(aktivg),'String'));
   b(aktivg,4)=min([max([v,ylim(1)]),ylim(2)]);
   set(bild(aktivg),'YData',[0 b(aktivg,4)]);
   set(ed_yb(aktivg),'String',num2str(b(aktivg,4)));
   
	
%Gegenstandseinstellung, Gegenstand zeichnen	
case 'init_ed_g'               
   
   for x=1:gg
   
	position   = [0.1 0.15 0.05 0.03];
   xval       = geg(gg,1);
%Editor für Gegenstandspos.
   ed_g(x) = uicontrol( ...
       'Parent',figure_1, ...
       'Style','edit', ...
       'String',num2str(xval),...
       'Units','normalized', ...
       'Position',position, ...
       'Visible','off', ...
       'Callback','linsen ed_g' ...
       );
  
%Text über Editor 
   textpos  = [position(1)+position(3)/2,position(2)+position(4)/2+textshift];
   text_ed_g(x) = text( ...
       'Position',textpos, ...
       'Parent',axes_1, ...
       'FontUnits',fontunits, ...
       'FontSize',fontsize, ...
       'HorizontalAlignment','center', ...
       'Visible','off', ...
       'VerticalAlignment','middle', ...
       'String','Gegenstandsposition' ...
       );
%Beschriftung    
   textpos= [0.2 0.25];
   text_geg(x) = text( ...
       'Position',textpos, ...
       'Parent',axes_1, ...
       'FontUnits',fontunits, ...
       'Color','red',...
       'FontSize',0.03, ...
       'Visible','off',...
       'HorizontalAlignment','center', ...
       'String',['Daten zu ',num2str(x),'.Gegenstand und Bild'],...
       'Color','red',...
       'VerticalAlignment','middle' ...
       );
   
    end
    
    set(text_geg(aktivg),'Visible','on');
    set(text_ed_g(aktivg),'Visible','on');
    set(ed_g(aktivg),'Visible','on');
    
case 'init_ed_yg'               
   
   
   for x=1:gg
	position   = [0.1 0.05 0.05 0.03];
   xval       = geg(x,4);
%Editor für Gegenstandshöhe
   ed_yg(x) = uicontrol( ...
       'Parent',figure_1, ...
       'Style','edit', ...
       'String',num2str(xval),...
       'Units','normalized', ...
       'Position',position, ...
       'Visible','off', ...
       'Callback','linsen ed_yg' ...
       );
%Text über Editor  
   textpos  = [position(1)+position(3)/2,position(2)+position(4)/2+textshift];
   text_ed_yg(x) = text( ...
       'Position',textpos, ...
       'Parent',axes_1, ...
       'FontUnits',fontunits, ...
       'FontSize',fontsize, ...
       'Visible','off', ...
       'HorizontalAlignment','center', ...
       'VerticalAlignment','middle', ...
       'String','Gegenstandshöhe' ...
       );
  	end
     
   set(text_ed_yg(aktivg),'Visible','on');
   set(ed_yg(aktivg),'Visible','on');
	 
    
case 'init_gegenstand'
   
   for x=1:gg
%Gegenstand zeichnen
   gegenstand(x)=line(...
      'Parent',axes_2, ...
		'ButtonDownFcn','linsen hit_gegenstand',...
		'EraseMode','xor', ...
      'Color','green',...
      'LineWidth',2,...
		'XData',[geg(x,1) geg(x,2)], ...
		'YData',[geg(x,3) geg(x,4)] ...
      );
   end
gegenstand=gegenstand(1:gg);

case 'ed_g'
%Callbackroutine für Gegenstandspos.-Editor   
   v = str2num(get(ed_g(aktivg),'String'));
   geg(aktivg,1)=min([max([v,xlim(1)]),xlim(2)]);
   geg(aktivg,2)=geg(aktivg,1);
   set(gegenstand(aktivg),'XData',[geg(aktivg,1) geg(aktivg,2)]);
   set(ed_g(aktivg),'String',num2str(geg(aktivg,1)));
   linsen('rechnung');
   
case 'ed_yg'
%Callbackroutine für Gegenstandshöhen-Editor 
   v = str2num(get(ed_yg(aktivg),'String'));
   geg(aktivg,4)=min([max([v,ylim(1)]),ylim(2)]);
   set(gegenstand(aktivg),'YData',[0 geg(aktivg,4)]);
   set(ed_yg(aktivg),'String',num2str(geg(aktivg,4)));
   linsen('rechnung');

case 'hit_gegenstand'
%Callbackroutine wenn mit Mouse Gegenstand angeklickt wird
 	axes(axes_2);
   set(figure_1,'WindowButtonUpFcn','linsen end_move_gegenstand');
   set(figure_1,'WindowButtonMotionFcn','linsen move_gegenstand');
   %Daten für aktuellen Gegenstand anzeigen
   set(ed_b(aktivg),'Visible','off');
   set(ed_yb(aktivg),'Visible','off');
   set(text_ed_b(aktivg),'Visible','off');
   set(text_ed_yb(aktivg),'Visible','off');
   set(ed_g(aktivg),'Visible','off');
   set(ed_yg(aktivg),'Visible','off');
   set(text_ed_g(aktivg),'Visible','off');
   set(text_ed_yg(aktivg),'Visible','off');
   set(gegenstand(aktivg),'Color','green');
   set(bild(aktivg),'Color','yellow');
   set(text_geg(aktivg),'Visible','off');
   
   aktivg=(1:gg)*(gegenstand==gcbo)';
   xxx=0;
   if aktivg==0
      aktivg=(1:gg)*(bild==gcbo)';
      xxx=1;
   end
   
   set(text_geg(aktivg),'Visible','on');
   set(ed_b(aktivg),'Visible','on');
   set(ed_yb(aktivg),'Visible','on');
   set(text_ed_b(aktivg),'Visible','on');
   set(text_ed_yb(aktivg),'Visible','on');
   set(ed_g(aktivg),'Visible','on');
   set(ed_yg(aktivg),'Visible','on');
   set(text_ed_g(aktivg),'Visible','on');
   set(text_ed_yg(aktivg),'Visible','on');
   set(gegenstand(aktivg),'Color','red');
   set(bild(aktivg),'Color','red');
   
case 'move_gegenstand'
   %Routine wenn Gegenstand mit Mouse gezogen wird 
   cp = get(axes_2,'CurrentPoint');
   xval = min([max([cp(1,1),xlim(1)]),xlim(2)]);
   yval = min([max([cp(1,2),ylim(1)]),ylim(2)]);
   if xxx==0
   set(gegenstand(aktivg),'XData',[xval xval],'YData',[0,yval]);
   set(ed_g(aktivg),'String',num2str(xval));
   set(ed_yg(aktivg),'String',num2str(yval));
   geg(aktivg,:)=[xval,xval,0,yval];
   else
   set(bild(aktivg),'XData',[xval xval],'YData',[0,yval]);
   set(ed_b(aktivg),'String',num2str(xval));
   set(ed_yb(aktivg),'String',num2str(yval));
   b(aktivg,:)=[xval,xval,0,yval];
	end

   linsen('rechnung');
   
case 'end_move_gegenstand'
%Routine wenn Gegenstand nach Mouse-Aktion abgesetzt wird   
   set(figure_1,'WindowButtonMotionFcn','');
   set(figure_1,'WindowButtonUpFcn','');
   
   linsen('rechnung');
   
%Linseneinstellungen, Linse zeichnen, Blende wird alls Linse mit f=0 bezeichnet
   
case 'init_ed_lins_x'               
  
  for x=1:a
    
   position   = [0.45 0.15 0.05 0.03];
   xval       = lins(x,1);
%Editor für Linsenpos.
   ed_lins_x(x) = uicontrol( ...
       'Parent',figure_1, ...
       'Style','edit', ...
       'String',num2str(xval),...
       'Units','normalized', ...
       'Position',position, ...
       'Visible','off', ...
       'Callback','linsen ed_lins_x' ...
       );
 
%Text über Editor
   textpos  = [position(1)+position(3)/2,position(2)+position(4)/2+textshift];
   text_ed_lins_x(x) = text( ...
       'Position',textpos, ...
       'Parent',axes_1, ...
       'FontUnits',fontunits, ...
       'FontSize',fontsize, ...
       'Visible','off',...
       'HorizontalAlignment','center', ...
       'VerticalAlignment','middle' ...
       );
%Beschriftung    
   textpos= [0.55 0.25];
   text_linsen(x) = text( ...
       'Position',textpos, ...
       'Parent',axes_1, ...
       'FontUnits',fontunits, ...
       'Color','red',...
       'FontSize',0.03, ...
       'Visible','off',...
       'HorizontalAlignment','center', ...
       'VerticalAlignment','middle' ...
       );
   
%Text 'auffüllen' mit Unterscheidung ob Linse/Blende    
    if x>bl
       set(text_ed_lins_x(x),'String',['x-Koordinate der ',num2str(x-bl),'.Blende']);
    else
       set(text_ed_lins_x(x),'String',['x-Koordinate der ',num2str(x),'.Linse']);
    end  
    
    if x>bl
       set(text_linsen(x),'String',['Einstellungen der ',num2str(x-bl),'.Blende']);
    else
       set(text_linsen(x),'String',['Einstellungen der ',num2str(x),'.Linse']);
    end  

    end
    
   set(text_linsen(aktivl),'Visible','on'); 
   set(ed_lins_x(aktivl),'Visible','on');
   set(text_ed_lins_x(aktivl),'Visible','on');
   
case 'init_ed_lins_r'               
  
   for x=1:a
     
   position   = [0.6 0.15 0.05 0.03];
   xval       = lins(x,2);
%Editor für Linsenradius
   ed_lins_r(x) = uicontrol( ...
       'Parent',figure_1, ...
       'Style','edit', ...
       'String',num2str(xval),...
       'Units','normalized', ...
       'Position',position, ...
       'Visible','off', ...
       'Callback','linsen ed_lins_r' ...
       );
%Text über Editor  
   textpos  = [position(1)+position(3)/2,position(2)+position(4)/2+textshift];
   text_ed_lins_r(x) = text( ...
       'Position',textpos, ...
       'Parent',axes_1,...
       'Visible','off',...
       'FontUnits',fontunits, ...
       'FontSize',fontsize, ...
       'HorizontalAlignment','center', ...
       'VerticalAlignment','middle', ...
       'String','Linsenradius' ...
       );
     if x>bl
       set(text_ed_lins_r(x),'String','Blendenradius');
     end   

   end
 
 set(ed_lins_r(aktivl),'Visible','on');
 set(text_ed_lins_r(aktivl),'Visible','on');
 
case 'init_ed_lins_f'               
   
  for x=1:bl
    
   position   = [0.45 0.05 0.05 0.03];
   xval       = lins(x,3);
%Editor für Linsenbrennweite
   ed_lins_f(x) = uicontrol( ...
       'Parent',figure_1, ...
       'Style','edit', ...
       'String',num2str(xval),...
       'Units','normalized', ...
       'Position',position, ...
       'Visible','off', ...
       'Callback','linsen ed_lins_f' ...
       );
 
%Text über Editor
   textpos  = [position(1)+position(3)/2,position(2)+position(4)/2+textshift];
   text_ed_lins_f(x) = text( ...
       'Position',textpos, ...
       'Parent',axes_1, ...
       'FontUnits',fontunits, ...
       'Visible','off',...
       'FontSize',fontsize, ...
       'HorizontalAlignment','center', ...
       'VerticalAlignment','middle', ...
       'String','Brennweite' ...
       );
 
 end
 
if aktivl<=bl 
set(ed_lins_f(aktivl),'Visible','on');
set(text_ed_lins_f(aktivl),'Visible','on'); 
end

case 'init_linse'
   
  for x=1:bl
%Linse zeichnen
    linse(x)=line(...
      'Parent',axes_2, ...
		'ButtonDownFcn','linsen hit_linse',...
		'EraseMode','xor', ...
		'Visible','on',...
		'Color','blue',	...
		'XData',[lins(x,1) lins(x,1)], ...
		'YData',[-lins(x,2) lins(x,2)] ...
      );
end



  for x=1:a
%Obere Einfassung für Linse zeichnen   
    linse_or(x)=line(...
      'Parent',axes_2, ...
      'ButtonDownFcn','linsen hit_linse',...
      'EraseMode','xor', ...
      'LineWidth',4,...
   	'Color','black',	...
		'XData',[lins(x,1) lins(x,1)], ...
		'YData',[lins(x,2) ylim(2)] ...
      );
   

%Untere Einfassung für Linse zeichnen   
   linse_ur(x)=line(...
      'Parent',axes_2,...
      'EraseMode','xor',...
      'ButtonDownFcn','linsen hit_linse',...
      'LineWidth',4,...
   	'Color','black',...
		'XData',[lins(x,1) lins(x,1)], ...
		'YData',[ylim(1) -lins(x,2)] ...
      );
  end 
  
%Linieninit. für geometr Darstellung
  for i=1:bl
    for k=1:6
     gd_line(i,k)=line('Parent',axes_2,...
	  'Color',[0,0,0.1],...
	  'XData',[1000 1000],...
	  'YData',[1000 1000],...
	  'Visible','off',...
	  'EraseMode','xor' ...
	  );
    end
  end
  gd_line=gd_line(1:bl,1:6);
  
  
case 'init_brenn'
    
  for x=1:bl
%Brennpkt 1 für Linse zeichnen  
    brenn1(x)=line(...
     	'Parent',axes_2, ...
		'ButtonDownFcn','linsen hit_brenn1',...
		'EraseMode','xor', ...
      'Color','blue',	...
      'Visible','off',...
		'XData',[lins(x,1)-lins(x,3) lins(x,1)-lins(x,3)], ...
		'YData',[-5 5] ...
      );
%Brennpkt. 2 für Linse zeichnen  
    brenn2(x)=line(...
      'Parent',axes_2, ...
      'ButtonDownFcn','linsen hit_brenn2',...
      'Visible','off',...
		'EraseMode','xor', ...
		'Color','blue',...
		'XData',[lins(x,1)+lins(x,3) lins(x,1)+lins(x,3)], ...
		'YData',[-5 5] ...
      );
   end
   
   if aktivl<=bl
   set(brenn1(aktivl),'Visible','on');
   set(brenn2(aktivl),'Visible','on');
   end

case 'ed_lins_x'
%Callbackroutine für Editor für Linsenpos.   
   v = str2num(get(ed_lins_x(aktivl),'String'));
   lins(aktivl,1)=min([max([v,xlim(1)]),xlim(2)]);
   if aktivl<=bl
   set(linse(aktivl),'XData',[lins(aktivl,1) lins(aktivl,1)]);
   set(ed_lins_x(aktivl),'String',num2str(lins(aktivl,1)));
   set(brenn1(aktivl),'XData',...
       [lins(aktivl,1)-lins(aktivl,3) lins(aktivl,1)-lins(aktivl,3)]);
   set(brenn2(aktivl),'XData',...
      [lins(aktivl,1)+lins(aktivl,3) lins(aktivl,1)+lins(aktivl,3)]);
   end
   set(linse_ur(aktivl),'XData',...
       [lins(aktivl,1) lins(aktivl,1)],'YData',...
       [xlim(1),-lins(aktivl,2)]);
   set(linse_or(aktivl),'XData',[lins(aktivl,1) lins(aktivl,1)],...
       'YData',[lins(aktivl,2),xlim(2)]);
   linsen('rechnung');

case 'ed_lins_r'
%Callbackroutine für Editor für Linsenradius    
   v = str2num(get(ed_lins_r(aktivl),'String'));
   lins(aktivl,2) = abs(min([max([v,ylim(1)]),ylim(2)]));
   if aktivl<=bl
   set(linse(aktivl),'YData',[-lins(aktivl,2) lins(aktivl,2)]);
   end
   set(ed_lins_r(aktivl),'String',num2str(lins(aktivl,2)));   
   set(linse_ur(aktivl),'XData',...
       [lins(aktivl,1) lins(aktivl,1)],'YData',[xlim(1),-lins(aktivl,2)]);
   set(linse_or(aktivl),'XData',...
       [lins(aktivl,1) lins(aktivl,1)],'YData',[lins(aktivl,2),xlim(2)]);
	linsen('rechnung');

case 'ed_lins_f'
%Callbackroutine für Editor für Linsenbrennweite   
   if aktivl<=bl
   v = str2num(get(ed_lins_f(aktivl),'String'));
   set(brenn1(aktivl),'XData',[lins(aktivl,1)-v lins(aktivl,1)-v]);
   set(brenn2(aktivl),'XData',[lins(aktivl,1)+v lins(aktivl,1)+v]);
   lins(aktivl,3)=v;
   linsen('rechnung');
   end
   
case 'hit_linse'
%Callbackroutine wenn Linse mit Mouse angeklickt wird
   axes(axes_2);
   set(figure_1,'WindowButtonUpFcn','linsen end_move_linse');
   set(figure_1,'WindowButtonMotionFcn','linsen move_linse');
%Daten für aktive Linse anzeigen
   set(ed_lins_x(aktivl),'Visible','off');
   set(ed_lins_r(aktivl),'Visible','off');
   set(text_ed_lins_x(aktivl),'Visible','off');
   set(text_ed_lins_r(aktivl),'Visible','off');
   set(text_linsen(aktivl),'Visible','off')
   
   if aktivl<=bl
   set(text_ed_lins_f(aktivl),'Visible','off');
   set(ed_lins_f(aktivl),'Visible','off');
   set(linse(aktivl),'Color','blue');
   set(brenn1(aktivl),'Visible','off');
   set(brenn2(aktivl),'Visible','off');
   set(brenn1(aktivl),'Color','blue');
   set(brenn2(aktivl),'Color','blue');
end

   aktivl=(1:bl)*(linse(1:bl)==gcbo)';
   if aktivl==0
      aktivl=(1:a)*(linse_ur(1:a)==gcbo)';
   end
   if aktivl==0
      aktivl=(1:a)*(linse_or(1:a)==gcbo)';
   end
   
   set(ed_lins_x(aktivl),'Visible','on');
   set(ed_lins_r(aktivl),'Visible','on');
   set(text_ed_lins_x(aktivl),'Visible','on');
   set(text_ed_lins_r(aktivl),'Visible','on');
   set(text_linsen(aktivl),'Visible','on')
   
   if aktivl<=bl
   set(brenn1(aktivl),'Visible','on');
   set(brenn2(aktivl),'Visible','on');
   set(text_ed_lins_f(aktivl),'Visible','on');
   set(linse(aktivl),'Color','red')
   set(brenn1(aktivl),'Color','red');
   set(brenn2(aktivl),'Color','red');
   set(ed_lins_f(aktivl),'Visible','on');
   end

case 'move_linse'
%Routine wenn Linse mit Mouse gezogen wird    
   cp = get(axes_2,'CurrentPoint');
   xval = min([max([cp(1,1),xlim(1)]),xlim(2)]);
   yval = abs(min([max([cp(1,2),ylim(1)]),ylim(2)]));
   lins(aktivl,:)=[xval,yval,lins(aktivl,3)];
   if aktivl<=bl
   set(linse(aktivl),'XData',[lins(aktivl,1) lins(aktivl,1)],...
       'YData',[-lins(aktivl,2) lins(aktivl,2)]);
   set(brenn1(aktivl),'XData',...
       [lins(aktivl,1)-lins(aktivl,3) lins(aktivl,1)-lins(aktivl,3)]);
   set(brenn2(aktivl),'XData',...
      [lins(aktivl,1)+lins(aktivl,3) lins(aktivl,1)+lins(aktivl,3)]);
   end
   set(linse_ur(aktivl),'XData',[lins(aktivl,1) lins(aktivl,1)],'YData',...
       [xlim(1),-lins(aktivl,2)]);
   set(linse_or(aktivl),'XData',[lins(aktivl,1) lins(aktivl,1)],'YData',...
       [lins(aktivl,2),xlim(2)]);
   set(ed_lins_x(aktivl),'String',num2str(xval));
   set(ed_lins_r(aktivl),'String',num2str(yval));
   linsen('rechnung');
   
case 'end_move_linse'
%Routine wenn Linse nach Mouse-Aktion abgesetzt wird
   set(figure_1,'WindowButtonMotionFcn','');
   set(figure_1,'WindowButtonUpFcn','');
   linsen('rechnung');
   
case 'hit_brenn1'
%Routine wenn Brennpkt 1 angeklickt wird
   if aktivl<=bl
   axes(axes_2);
   set(figure_1,'WindowButtonUpFcn','linsen end_move_brenn1');
   set(figure_1,'WindowButtonMotionFcn','linsen move_brenn1');   
   end

case 'move_brenn1'
%Routine wenn Brennpkt 1 mit Mouse gezogen wird   
   cp = get(axes_2,'CurrentPoint');
   lins(aktivl,3) = lins(aktivl,1)-cp(1,1);
   set(brenn1(aktivl),'XData',...
       [lins(aktivl,1)-lins(aktivl,3) lins(aktivl,1)-lins(aktivl,3)]);
   set(brenn2(aktivl),'XData',...
       [lins(aktivl,1)+lins(aktivl,3) lins(aktivl,1)+lins(aktivl,3)]);
   set(ed_lins_f(aktivl),'String',num2str(lins(aktivl,3)));
   linsen('rechnung');

case 'end_move_brenn1'
%Routine wenn Brennpkt 1 nach Mouse-Aktion wieder abgesetzt wird   
   set(figure_1,'WindowButtonMotionFcn','');
   set(figure_1,'WindowButtonUpFcn','');
   linsen('rechnung');
   
case 'hit_brenn2'
%Routine wenn Brennpkt 2 angeklickt wird 
   if aktivl<=bl
   axes(axes_2);
   set(figure_1,'WindowButtonUpFcn','linsen end_move_brenn2');
   set(figure_1,'WindowButtonMotionFcn','linsen move_brenn2');   
   end
   
case 'move_brenn2'
%Routine wenn Brennpkt 2 mit Mouse gezogen wird       
   cp = get(axes_2,'CurrentPoint');
   lins(aktivl,3) = -1*(lins(aktivl,1)-cp(1,1));
   set(brenn1(aktivl),'XData',...
       [lins(aktivl,1)-lins(aktivl,3) lins(aktivl,1)-lins(aktivl,3)]);
   set(brenn2(aktivl),'XData',...
       [lins(aktivl,1)+lins(aktivl,3) lins(aktivl,1)+lins(aktivl,3)]);
   set(ed_lins_f(aktivl),'String',num2str(lins(aktivl,3)));
   linsen('rechnung');
      
  
case 'end_move_brenn2'
%Routine wenn Brennpkt 2 nach Mouse-Aktion wieder abgesetzt wird      
   set(figure_1,'WindowButtonMotionFcn','');
   set(figure_1,'WindowButtonUpFcn','');
   linsen('rechnung');

%Berechnung des Bildes   
case 'rechnung'   

%For-Schleife für mehrere Gegenstände
for anzg=1:gg
	%Abstand Linse-Gegenstand  
	lr=lins(1:bl,1);
	gr=repmat(geg(anzg,1),bl,1);
	lgr=(lr-gr);
	lins;

	%if-Abfrage ob alle Linsen auf der Gleichen Seite liegen
	if (length(lgr(lgr>0))==bl)|(length(lgr(lgr>0))==0)
      %Unterscheidung zw. links und rechts
      if lgr(1)>0
  	   	lg=1;
   	else
      	lg=0;
      	lgr=abs(lgr);
	   end
   
   	%if-Schleife zum überprüfen ob nur ein Minimum vorhanden ist
   	if sum((lgr==min(lgr)))==1
      	%Gegenstandsposition unter bz speichern
      	bz(1)=geg(anzg,1);
      	bz(2)=geg(anzg,4);
     
   		%For-Schleife zum berechnen der Zwischnenbilder  
  			for i=1:bl
   			%Zwischnenbildposition unter zb speichern
 				zb(1)=bz(1);
 				zb(2)=bz(2);
 				%Überprüfen ob es noch werde gibt die noch nicht durchlaufen worden sind
             if sum((lgr==1000))<bl
               %if-Schleife zum überprüfen ob nur ein Minimum vorhanden ist 
     				if sum((lgr==min(lgr)))==1
                  %Ermitteln der nähesten Linse   
                  posm=(lgr==min(lgr))'*[1:bl]';
                  %Unterscheitung:links oder rechts
                  if lg==1 
          				g=(lr(posm)-bz(1));
       				else
          				g=-(lr(posm)-bz(1));
                  end
                  f=lins(posm,3);
       				yg=bz(2);
  					end
  					%Abbildungsgleichung
  					bi=g*f/(g-f);
  					%Abbildungsmaßstab
  					yb=-yg*bi/g;
  					%Bildkoordinaten
               %Unterscheitung:links oder rechts 
               if lg==1
     					bz(1)=lins(posm,1)+bi;
  					else
     					bz(1)=(lins(posm,1)-bi);%neg!!!!!!!!!!
  					end
  
  					bz(2)=yb;
  					lgr(posm)=1000;
 					%Zwischenbilder neu setzen wenn es sich um das aktive Bild handelt
					if anzg==aktivg
  
						set(gd_line(i,1),'XData',[zb(1),lins(posm,1)],'YData',[zb(2),zb(2)]);
						set(gd_line(i,2),'XData',[lins(posm,1),bz(1)],'YData',[zb(2),bz(2)]);
						set(gd_line(i,3),'XData',[zb(1),lins(posm,1)],'YData',[zb(2),bz(2)]);
						set(gd_line(i,4),'XData',[lins(posm,1),bz(1)],'YData',[bz(2),bz(2)]);
						set(gd_line(i,5),'XData',[zb(1),bz(1)],'YData',[zb(2),bz(2)]);
						set(gd_line(i,6),'XData',[zb(1),zb(1)],'YData',[0,zb(2)]);
						%Erstes Zwischnenbild ist Gegestand: braucht nicht gezeichnet werden
						set(gd_line(1,6),'XData',[1000,1000],'YData',[1000,1000]);
					end
 				end
			end
		end

      %Speichern und zeichnen der neuen Bildposition(Editor auf neue Werte setzen)
 		b(anzg,1)=bz(1);
 		b(anzg,2)=bz(1);
 		b(anzg,3)=0;
 		b(anzg,4)=bz(2);
 
 		set(bild(anzg),'XData',[b(anzg,1),b(anzg,2)],'YData',[b(anzg,3),b(anzg,4)]);
		set(ed_b(anzg),'String',num2str(b(anzg,1)));
 		set(ed_yb(anzg),'String',num2str(b(anzg,4)));
	   end
	
	      
	      
	      
	      
	      
	      
     
	if vig==1      
%
%Vignettierung
%

	if aktivg==anzg
	%Zerlegung in wieviele Punkte
	zerl1=70;
   zerl2=500;
   %Blende die Brennweite null zuordnen
   lins(bl+1:a,3)=0;
	%Def. Variable Vigenettierung
	vignett=zeros(zerl2,zerl1);
	%Zerlegung des Gegenstandes in mehrere Punkte
   bzneu=linspace(0,bz(2),zerl1);
	%Verschiedene Abstrahlungspunkte
	phi=linspace(0.001-pi/2,pi/2-0.001,zerl2);
	%Berechnung des Strahlengangs der einzelnen Punkte
	
	for p=1:zerl1
	
	%Abstand Linse-Gegenstand  
	lr=lins(1:a,1);
	gr=repmat(geg(anzg,1),a,1);
	lgr=(lr-gr);
	

	%if-Abfrage ob alle Linsen auf der Gleichen Seite liegen
	if (length(lgr(lgr>0))==a)|(length(lgr(lgr>0))==0)
      %Unterscheidung zw. links und rechts
      if lgr(1)>0
  	   	lg=1;
   	else
      	lg=0;
      	lgr=abs(lgr);
	   end
   
   	%if-Schleife zum überprüfen ob nur ein Minimum vorhanden ist
   	if sum((lgr==min(lgr)))==1
      	%Gegenstandsposition unter bz speichern
      	bz(1)=geg(anzg,1);
      	bz(2)=geg(anzg,4);
        
	  pl=ones(zerl2,2);
	  %For-Schleife zum berechnen der Zwischnenbilder  
  			for i=1:a
   			%Zwischnenbildposition unter zb speichern
			
			        zb=bz(1);
 				zbneu(p)=bzneu(p);
 				%Überprüfen ob es noch Werte gibt die noch nicht durchlaufen worden sind
             if sum((lgr==1000))<a
               %if-Schleife zum überprüfen ob nur ein Minimum vorhanden ist 
     				if sum((lgr==min(lgr)))==1
                  %Ermitteln der nähesten Linse(Blende)  
                  posm=(lgr==min(lgr))'*[1:a]';
                  %Unterscheitung:links oder rechts
                  if lg==1 
          				g=(lr(posm)-bz(1));
       				else
          				g=-(lr(posm)-bz(1));
                  end
                  f=lins(posm,3);
       				yg=bzneu(p);
			      end
			      
		%Speichern des Linsenradius	      
		R=lins(posm,2);	      
		%Berechnung für Vignettierung(verschiedne Abstrahlungswinkel)
      if i==1
         x=tan(phi)*(g)+yg;
      else
         x=(-(x-yg)/bi)*g+yg;
      end   
		%Untersuchung ob Strahl auf Blende trifft
		pl(:,2)=((x<R)&(x>-R))';
		%Vergleich mit vorherigen Bild
      pl(:,1)=pl(:,1)&pl(:,2);
		%Abbildungsgleichung
      
      if f~=0
		  
  					bi=g*f/(g-f);
  					%Abbildungsmaßstab
  					yb=-yg*bi/g;
  					%Bildkoordinaten
               %Unterscheitung:links oder rechts 
               if lg==1
     					bz(1)=lins(posm,1)+bi;
  					else
     					bz(1)=(lins(posm,1)-bi);%neg!!!!!!!!!!
  					end
  					bzneu(p)=yb;
         else
                 bi=-g;
         end
  					lgr(posm)=1000;
					
				
              end
              
			      end
			      vignett(:,p)=pl(:,1);  

		end

              end
	      end      
	    end 
	    
	    
   %Vektor der Vignettierungsdaten enthält      
   vignett= sum(vignett)/max(sum(vignett));
   y1=linspace(0,1-1/zerl1,zerl1);
	y2=linspace(1/zerl1,1,zerl1);
	y=[y1;y2;y2;y1;y1];
	x=repmat([0;0;1;1;0],1,zerl1);

%Patch zum Darstellung der Vignettierung	
	pat =patch(x,y,vignett, ...
      'parent',axes_3,...
      'EraseMode','none',...
      'Visible','on',...
      'EdgeColor','none');
      
	caxis([0 1]);   
	colormap('gray');

	end      
	     
	      
	      
	      
end



%drei Slider:   
case 'init_slider_l'               
   position   = [0.88 0.14 0.10 0.02];   
   smin       = 1;    
   smax       = 10;    
   xval       = bl;    
   sliderstep = [0.1 0.2];    
   textshift1 = 0.025;
%Slider für Linsenanz.   
   slider_l = uicontrol( ...       
      'Parent',figure_1, ...       
      'Style','slider', ...       
      'String','Clear', ...       
      'Min',smin, ...       
      'Max',smax, ...       
      'Value',xval, ...    
      'SliderStep',sliderstep, ...
      'Units','normalized', ...      
      'Position',position, ...      
      'ToolTipString','Slider für Linsenzahl', ...
      'Visible','on', ...       
      'Callback','linsen slider_l' ...       
      );  
%Text für Slider für Linsenanz.
   textpos  = [position(1),position(2)+position(4)/2+textshift1]; 
   slider_l_text_1a = text( ...       
      'Position',textpos, ...       
      'Parent',axes_1, ...       
      'FontUnits',fontunits, ...    
      'FontSize',fontsize, ...      
      'HorizontalAlignment','center', ...
      'Visible','on',...
      'VerticalAlignment','middle', ...      
      'String',num2str(smin) ...       
      );                          
   textpos  = [position(1)+position(3),position(2)+position(4)/2+textshift1]; 
   slider_l_text_1b = text( ...       
      'Position',textpos, ...      
      'Parent',axes_1, ...      
      'FontUnits',fontunits, ...      
      'FontSize',fontsize, ...       
      'HorizontalAlignment','center', 	...
      'VerticalAlignment','middle', ...   
      'String',num2str(smax) ...      
      );                            
   textpos  = [position(1)+position(3)/2,position(2)+position(4)/2+textshift1]; 
   slider_l_text_1c = text( ...       
      'Position',textpos, ...    
      'Parent',axes_1,	...      
      'FontUnits',fontunits, ... 
      'FontSize',fontsize, ...        
      'HorizontalAlignment','center', ...   
      'VerticalAlignment','middle', ...     
      'String',num2str(xval) ...       
      );                           
   textpos  = [position(1)+position(3)/2,position(2)+position(4)/2-textshift1];
   slider_l_text_1d = text( ...    
      'Position',textpos, ...        
      'Parent',axes_1, ...      
      'FontUnits',fontunits, ...       
      'FontSize',fontsize, ...      
      'HorizontalAlignment','center', ... 
      'VerticalAlignment','middle', ...       
      'String','Linsenanzahl' ...      
      );
   
case 'slider_l'   
%Callbakroutine für Slider für Linsenanz.
   xval=round(get(slider_l,'Value'));
   set(slider_l_text_1c,'String',num2str(xval)); 
   set(slider_l,'Value',xval);
   hah=a-bl;
   bl=xval;
   a=bl+hah;
   linsen('NEUinit');
   
case 'init_slider_b'               
%Slider für Blendenanz.
   position   = [0.88 0.23 0.10 0.02];   
   smin       = 0;    
   smax       = 10;    
   xval       = hah;    
   sliderstep = [0.1 0.2];    
   
   slider_b = uicontrol( ...       
      'Parent',figure_1, ...       
      'Style','slider', ...       
      'String','Clear', ...       
      'Min',smin, ...       
      'Max',smax, ...       
      'Value',xval, ...    
      'SliderStep',sliderstep, ...
      'Units','normalized', ...      
      'Position',position, ...      
      'ToolTipString','Slider für Blendenzahl', ...
      'Visible','on', ...       
      'Callback','linsen slider_b' ...       
      );  
%Text für Slider für Blendenanz.    
   textpos  = [position(1),position(2)+position(4)/2+textshift1]; 
   slider_b_text_1a = text( ...       
      'Position',textpos, ...       
      'Parent',axes_1, ...       
      'FontUnits',fontunits, ...    
      'FontSize',fontsize, ...      
      'HorizontalAlignment','center', ...
      'Visible','on',...
      'VerticalAlignment','middle', ...      
      'String',num2str(smin) ...       
      );                          
   textpos  = [position(1)+position(3),position(2)+position(4)/2+textshift1]; 
   slider_b_text_1b = text( ...       
      'Position',textpos, ...      
      'Parent',axes_1, ...      
      'FontUnits',fontunits, ...      
      'FontSize',fontsize, ...       
      'HorizontalAlignment','center', 	...
      'VerticalAlignment','middle', ...   
      'String',num2str(smax) ...      
      );                            
   textpos  = [position(1)+position(3)/2,position(2)+position(4)/2+textshift1]; 
   slider_b_text_1c = text( ...       
      'Position',textpos, ...    
      'Parent',axes_1,	...      
      'FontUnits',fontunits, ... 
      'FontSize',fontsize, ...        
      'HorizontalAlignment','center', ...   
      'VerticalAlignment','middle', ...     
      'String',num2str(xval) ...       
      );                           
   textpos  = [position(1)+position(3)/2,position(2)+position(4)/2-textshift1];
   slider_b_text_1d = text( ...    
      'Position',textpos, ...        
      'Parent',axes_1, ...      
      'FontUnits',fontunits, ...       
      'FontSize',fontsize, ...      
      'HorizontalAlignment','center', ... 
      'VerticalAlignment','middle', ...       
      'String','Blendenanzahl' ...      
      );
   
case 'slider_b'   
%Callbackroutine für Slider für Blendenanzahl
   xval=round(get(slider_b,'Value'));
   set(slider_b_text_1c,'String',num2str(xval)); 
   set(slider_b,'Value',xval);
   hah=xval;
   a=bl+hah;
   linsen('NEUinit');   
      
case 'init_slider_geg'               
%Slider für Gegenstandsanzahl
   position   = [0.88 0.05 0.10 0.02];   
   smin       = 1;    
   smax       = 10;    
   xval       = gg;    
   sliderstep = [0.1 0.2];    
   
   slider_geg = uicontrol( ...       
      'Parent',figure_1, ...       
      'Style','slider', ...       
      'String','Clear', ...       
      'Min',smin, ...       
      'Max',smax, ...       
      'Value',xval, ...    
      'SliderStep',sliderstep, ...
      'Units','normalized', ...      
      'Position',position, ...      
      'ToolTipString','Slider für Gegenstandsanzahl', ...
      'Visible','on', ...       
      'Callback','linsen slider_geg' ...       
      );  
%Text für Slider für Gegenstandsanzahl 
   textpos  = [position(1),position(2)+position(4)/2+textshift1]; 
   slider_geg_text_1a = text( ...       
      'Position',textpos, ...       
      'Parent',axes_1, ...       
      'FontUnits',fontunits, ...    
      'FontSize',fontsize, ...      
      'HorizontalAlignment','center', ...
      'Visible','on',...
      'VerticalAlignment','middle', ...      
      'String',num2str(smin) ...       
      );                          
   textpos  = [position(1)+position(3),position(2)+position(4)/2+textshift1]; 
   slider_geg_text_1b = text( ...       
      'Position',textpos, ...      
      'Parent',axes_1, ...      
      'FontUnits',fontunits, ...      
      'FontSize',fontsize, ...       
      'HorizontalAlignment','center', 	...
      'VerticalAlignment','middle', ...   
      'String',num2str(smax) ...      
      );                            
   textpos  = [position(1)+position(3)/2,position(2)+position(4)/2+textshift1]; 
   slider_geg_text_1c = text( ...       
      'Position',textpos, ...    
      'Parent',axes_1,	...      
      'FontUnits',fontunits, ... 
      'FontSize',fontsize, ...        
      'HorizontalAlignment','center', ...   
      'VerticalAlignment','middle', ...     
      'String',num2str(xval) ...       
      );                           
   textpos  = [position(1)+position(3)/2,position(2)+position(4)/2-textshift1];
   slider_geg_text_1d = text( ...    
      'Position',textpos, ...        
      'Parent',axes_1, ...      
      'FontUnits',fontunits, ...       
      'FontSize',fontsize, ...      
      'HorizontalAlignment','center', ... 
      'VerticalAlignment','middle', ...       
      'String','Gegenstandsanzahl' ...      
      );
case 'slider_geg'   
%Callbackroutine für Slider für Gegenstandsanzahl
   xval=round(get(slider_geg,'Value'));
   set(slider_geg_text_1c,'String',num2str(xval)); 
   set(slider_geg,'Value',xval);
   gg=xval;
   linsen('NEUinit');   
   
case 'NEUinit'   
%Routine die Aufgerufen wird wenn Linsen/Blenden/Slideranzahl verändert wird
   close(figure_1);
   clear text_ed_lins_x text_ed_lins_f text_ed_lins_r text_ed_g text_ed_b text_ed_yb text_ed_yg text_geg text_linsen
   clear ed_lins_x ed_lins_f ed_lins_r ed_g ed_yg ed_b ed_yb gegenstand brenn2 brenn1 linse linse_or linse_ur bild
   text_ed_lins_x=0;
   text_ed_lins_f=0;
   text_ed_lins_r=0;
   text_ed_g=0 ;
   text_ed_b=0 ;
   text_ed_yb=0 ;
   text_ed_yg=0 ;
   text_geg=0 ;
   text_linsen=0;
	ed_lins_x=0 ;
	ed_lins_f=0 ;
   ed_lins_r=0 ;
   ed_g =0;
   ed_yg =0;
   ed_b =0;
   ed_yb=0;
   gegenstand=0; 
   brenn2 =0;
   brenn1 =0;
   linse =0;
   linse_or=0; 
   linse_ur =0;
   bild=0;

   xx=size(b);
   
   xx=xx(1);
   yy=size(lins);
   yy=yy(1);
   if xx<gg
     b=[b;repmat([0,0,0,24],(gg-xx),1)];
     geg=[geg;repmat([30,30,0,20],(gg-xx),1)];
     b((xx+1):gg,1:2)=b((xx+1):gg,1:2)+repmat(((xx+1):gg)*5,2,1)';
     geg((xx+1):gg,1:2)=geg((xx+1):gg,1:2)+repmat(((xx+1):gg)*5,2,1)';
  	else   
   	geg=geg(1:xx,:);     
      b=b(1:xx,:); 
   end
   if yy<a
     lins=[lins;repmat([0,30,20],(a-yy),1)];
     lins((yy+1):a,1)=lins((yy+1):a,1)+(((yy+1):a)*5)';
   else   
   	lins=lins(1:yy,:);      
   end
   
   if aktivl>a
      aktivl=1;
   end
   
   if aktivg>gg
      aktivg=1;
   end
   linsen('init');
 
 case 'init_menu'  
%Menü für Einstellungen ob geomter. Darstellung und Vignettierung
menu1 = uimenu('Parent',figure_1, ...
	'Label','Linsen', ...
	'Tag','menu1');
menu11 = uimenu('Parent',menu1, ...
	'Callback','linsen menu11', ...
	'Label','Vignettierung off', ...
   'Tag','menu11');
  
menu12 = uimenu('Parent',menu1, ...
	'Callback','linsen menu12', ...
	'Label','Geometrische Darstellung off', ...
   'Tag','menu12');

set(axes_3,'Visible','off');
if gd==1
     set(gd_line,'Visible','on');
     gd=1;
     set(menu12,'Label','Geometrische Darstellung on')
end   
if vig==1
     
     vig=1;
     
     set(menu11,'Label','Vignettierung on')
     set(axes_3,'Visible','on');
     
end 



  case 'menu11'   
%Callbackroutine für menü für Vignettierung   
   
   label = get(gcbo,'Label');
   if strcmp(label,'Vignettierung off')
      
     vig=1;
      set(gcbo,'Label','Vignettierung on')
      
      set(axes_3,'Visible','on');
      
      linsen('rechnung');
   elseif strcmp(label,'Vignettierung on')
      
     vig=0;
      set(gcbo,'Label','Vignettierung off')
      set(axes_3,'Visible','off');
      
   end
   
   
 case 'menu12'   
%Callbackroutine für Menü für geometr. Darstellung
   
   label = get(gcbo,'Label');
   if strcmp(label,'Geometrische Darstellung off')
      set(gd_line,'Visible','on');
     gd=1;
      set(gcbo,'Label','Geometrische Darstellung on')
   elseif strcmp(label,'Geometrische Darstellung on')
      set(gd_line,'Visible','off');
     gd=0;
      set(gcbo,'Label','Geometrische Darstellung off')
    end
    
  
case 'init_axes_vig'
%Init für Achsen zur Darstellung des Vignettierungsbildes
colormap('gray');	
   axes_3 = axes(...
	'Parent',figure_1, ...
	'Units','normalized', ...
	'Position',[0.71 0.04 0.08 0.2], ...
	'Box','on', ...
	'Visible','on' ...
	);
    
    
	

otherwise                       
   error(['Unknown flag ''' flag '''.']);
   
end


   


%Ende des Programmes

%Bugs:
%*) Ändern der Linsen/Blenden/Gegenstandsanzahl
%*) Gegenstand zwischen 2 Linsen
%*) Editor für Linsenbrennweite
%*) Vignettierung in Spezialfällen