function [cams resto_cam]= camera2(num_cam,space,level,rotat,angle_cam)

%%
%% FUNZIONE:
%%
%% INPUT:
%% num_cam   : numero telecamere
%% angle_cam : ampiezza angolo visula delle telecamere
%%           : potrei permettere un angolo diverso per camere diverse?! 
%% space     : dimensioni dello spazio di ripresa
%% passo     : vettore con la distanza tra telecamere: 
%%             passox: distanza telecamere allineate stessa riga
%%             passoy = dist_row: distanza tra righe
%%             passoz = dist_livelli: distanza tra livelli
%% rotat     : vettore con i gradi di rotazione tra telecamere vicine:
%%             anglex,angley,anglez
%% level     : mi fornisce 
%%             row: il num travi sul soffitto sulle quali posso fissare le telecamere
%%             n_level: il numero di livello
            

%% OUTPUT:
%% cameras   : ogni colonna del vettore corrisponde ad una telecamera
%%             le prime tre righe contengono le coordinate x,y,z
%%             le rimanenti gli angoli inclinazione rispetto ai 3 piani


switch(nargin),
case 0
    disp('Too few arguements for cameras');
    return;
case 1,
    latox=5;
    latoy=5;
    latoz=5;
    space=[latox,latoy,latoz]';     %default misure dello spazio di ripresa
case 2,    
    cam_row  = floor((num_cam/2+2)/(1+space(2)/space(1)));
    if cam_row ~= 0,1
        level(1) = floor(space(1)/(cam_row-1));
    else
        cam_row=1;
        level(1) = space(1);
    end
    level(2) = floor(num_cam/2+2 - cam_row);
    level(3) = 2;                   %inserisco solo sul perimetro
    
case 3,
    if level(2)==0
        disp('number of rows must be >0 ');
        return
    end
    cam_row =floor(num_cam/level(2))+1;  
    rotat(1)=0;                  %ricontrollare con interfaccia15
    rotat(1)=pi/4/cam_row;       % rotazione angolox tra telecamere vicine
    rotat(2)=0;
    rotat(2)=pi/4/level(2);      % rotazione angoloy tra telecamere vicine
    rotat(3)=0;  
case 4
    angle_cam=pi/3;  %imposto angolo visuale uguale per tutte le telecamere
                                   
case 5,
    %do nothing
otherwise
    disp('Too many arguements for function cameras');
end;

if num_cam==1
    resto_cam=0;
    cams=[];
end

latox = space(1);
latoy = space(2);
latoz = space(3);

passox = level(1);
row    = level(2);
n_level= level(3);

if row > 1 
    dist_row = space(2)/(level(2)-1);
elseif row==1
    dist_row = space(2);
else
    dips('rows must be > 0');
    return;
end

anglex = rotat(1);
angley = rotat(2);
anglez = rotat(3);

cam_row     = floor(num_cam/row);        %forse meglio mettere ceil?
cam_row_max = floor(latox/passox) + 1 ;  %num max di telecamere per riga

%se il livello è 1 => posso inserire su tutto il soffitto
if n_level==1
    cam_livello_max= row*cam_row_max;
else
%altrimenti solo lungo il perimetro
    cam_livello_max= 2*cam_row_max + 2*(row-2);
end

% se il numero di telecamere supera quelle consentite per livello
% riempio completamente il livello corrente e do in uscita il numero
% di telecamere rimanenti da utilizzare al livello successivo

if num_cam  >= cam_livello_max
    cam_row  = cam_row_max;
    resto_cam= num_cam-cam_livello_max;
    cam_livello=num_cam-resto_cam;  %=cam_livello_max
else
    cam_livello=num_cam;
    resto_cam= 0;
    % ridristribuisco... ma forse era meglio evitare!!!!!!
    % perchè cambio il numero di row rispetto a quello imposto
    % e talvolta non rispetto il passo imposto!!
    % se pero' ho poche telecamere è utile per distribuirle meglio
    
    if n_level>1 
        %dovrei mettere in realtà if num_cam >2 & num_cam < cam_row
        if num_cam > 2
        cam_row  = floor((num_cam/2+2)/(1+space(2)/space(1)));        
        row      = floor(num_cam/2+2 - cam_row);  %metti row1 
        if cam_row>1
            passox   = space(1)/(cam_row-1);
        else
             cam_row = 2;  
             passox   = space(1);
        end
            %resto_cam= 0;
        
            if row > 1
                dist_row = space(2)/(row-1) ;
            else
                dist_row = space(2);
            end
        
        else
             cam_row  = num_cam;
             passox   = space(1);
             row      = 2;              
             % in realtà è una ma metto 2 per far funzionere ricorsione
        end
    else
        cam_row  = ceil(num_cam/row);
        %se faccio floor(500/47) rimangono fuori 30 telecamere?!?!
        %resto_cam=0;
        %resto_cam= mod(num_cam/row);
        if cam_row~=0 & cam_row~=1
            passox   = latox/(cam_row-1);   %distribuisco meglio?!!!!
        else
            if num_cam > 2
                cam_row  = floor((num_cam/2+2)/(1+space(2)/space(1)));        
                row      = floor(num_cam/2+2 - cam_row);  %metti row1 
                if cam_row>1
                    passox   = space(1)/(cam_row-1);
                else
                     cam_row = 2;            %attento è una cavolata=> ne metto 2 quando dovrebbe essercene 1
                     passox   = space(1);
                end
                %resto_cam= 0;
        
                if row > 1
                    dist_row = space(2)/(row-1) ;
                else
                    dist_row = space(2);
                end
        
             else
                 cam_row  = num_cam;
                 passox   = space(1);
                 row      = 2;
                 
                 % in realtà è una ma metto 2 per far funzionere ricorsione
             end
        end
    end
    %cam_livello=cam_row*row;         
end

c = 1;
  j=1;
  while j<=floor(row/2)  
    i=0;
    while i<cam_row
        cams(c).position = [i*passox;(j-1)*dist_row;latoz];      
        cams(c).angles   = [-3*pi/4;...%-(j-1)*(pi/2.5)/(row-1)
                            0;...
                            -pi/4+i*(pi/2)/(cam_row-1)];
          
%         cams(c).angles   = [3*pi/4;...%-(j-1)*(pi/2.5)/(row-1)
%                             0;...
%                             pi/4];
        
%         
%         cams(c).angles   = [-pi;...%-(j-1)*(pi/2.5)/(row-1)
%                             pi/4+(n_level-1)*(pi/4)/(3);...
%                             -pi/4-i*(pi/2)/(cam_row-1)]; %-(j-1)*(pi/2)/(row-1)
%                         
%       cams(c).angles   = [-pi-i*(pi/2)/(cam_row-1)+(j-1)*(pi/2)/(row-1);...
%                             pi/4+(n_level-1)*(pi/4)/(4);...
%                             -pi/4-i*(pi/2)/(cam_row-1)];
        %cams(c).angles   = [-pi-i*anglex/cam_row;pi/4+(j-1)*angley;-pi/4-(n_level-1)*anglez;];
        c=c+1;
        if n_level>1 & j~=1
            i=i+cam_row;
        else
            i=i+1;
        end
    end 
     
    j=j+1;
end

%per metà riga ho:
if mod(row,2)== 1 & row~=2
    i=0;
    while i<floor(cam_row/2) 
        cams(c).position= [i*passox;(j-1)*dist_row;latoz];
        cams(c).angles=[ -pi;-pi/4;0];
        c=c+1;
        if n_level>1 & j~=1
            i=i+cam_row;
        else
            i=i+1;
        end
      
    end
    i=cam_row;
      if i==1 
        i=0;        %caso 1 camera per riga 
      end
    
    while i>=floor(cam_row/2)+1 
        cams(c).position= [(i-1)*passox;(j-1)*dist_row;latoz];
        cams(c).angles= [-pi;pi/4;0];
        c=c+1;
        if n_level>1 & j>1
            i=i-cam_row;
        else
            i=i-1;
        end
    end
     stop=floor(row/2)+2;
else 
     stop=floor(row/2)+1;
end

if cam_row==1
    j=stop-1;
else
    j=row;
end

while j>=stop
    i=0;
    while i<cam_row 
        cams(c).position = [i*passox;(j-1)*dist_row;latoz];
        cams(c).angles   = [3*pi/4;...%-(j-1)*(pi/2.5)/(row-1)
                    0;...
                    pi/4-i*(pi/2)/(cam_row-1)];

%         cams(c).angles   = [-pi-(j-row)*(pi/2)/(row-1);...
%                              pi/4+(n_level-1)*(pi/4)/(3);...
%                             pi/4+i*(pi/2)/(cam_row-1)];
        
        %cams(c).angles   = [ -pi+i*anglex;pi/4-(j-row)*angley;pi/4-(n_level-1)*anglez;];
        %cams(c).angles= [-pi/4+ i*anglex;-pi/4-(j-row)*angley;-pi/4-(n_level-1)*anglez];
        c=c+1;
        if n_level>1 & j<row
            i=i+cam_row;
        else
            i=i+1;
        end
    end
    
    j=j-1;
end
