%FIXEDCC Construction of fixed combiners, back-end routine
%
%   V = FIXEDCC(A,W,TYPE,NAME,PAR)
%
% INPUT
%   A      Dataset
%   W      A set of classifier mappings
%   TYPE   String defining the type of combination rule
%   NAME   The name of this combination rule, arbitrary
%   PAR    Possible parameter for combiner defined by TYPE
%
% OUTPUT
%   V      Mapping
%
% DESCRIPTION
% Define a mapping V which applies the combination rule TYPE to the
% set of mappings W. The set of mappings W should be a parallel
% combination (see MAPPINGS).
%
% TYPE defines the combining rule and can be any of the following:
% average, min, max, mean, median, prod, vote,
%
% Note that average is only possible for affine 2-class classifiers.
%
% When W is a set of classifiers and A a dataset (possibly the result
% of B*W, where W is again a set of classifiers) then:
%
%   V = FIXEDCC(W,[],TYPE)   combines the mappings W with the comb. rule TYPE
%   V = FIXEDCC(A,[],TYPE)   computes the combining output for dataset A
%   V = FIXEDCC(A,W,TYPE)    computes the combining output for dataset A,
%                            where W is trained using A
% 
% This is a back-end routine. Users should directly call the fixed combiners.
%
% EXAMPLES
% See prex_combining.
%
% SEE ALSO (<a href="http://37steps.com/prtools">PRTools Guide</a>)
% MAPPINGS, VOTEC, MAXC, MEANC, MEDIANC, MINC, PRODC, AVERAGEC

% $Id: fixedcc.m,v 1.3 2009/02/04 10:53:10 duin Exp $

function v = fixedcc(a,w,type,name,par)

		if nargin == 0
		% Without input, just return an completely empty combiner mapping (even
		% without defining the combination rule):

		v = prmapping(mfilename,'combiner');
		return
	end	

	if nargin < 5, par = []; end
	if isempty(a)
		% just return a combiner mapping with just the combining rule
		
		v = prmapping(mfilename,'combiner',{[],type,name,par});
		
	elseif isa(a,'prmapping') & isempty(w)
		
		% v = comb_classifier*fixedcc,
		% we combine a set of classifiers, not interesting, except for the
		% 'average' type, there a new affine transformation is computed:
		
		if isuntrained(a) % store untrained comb_classifier
			
			v = prmapping(mfilename,'untrained',{a,type,name,par});
			
		else              % handle or store trained comb_classifier and all info
			
			[nclass,classlist] = renumlab(getlabels(a));

			% Special case is to average affine coefficients for 'average' combining
			switch type
			 case 'average'
			  if ~(isaffine(a) & size(classlist,1) == 2)
				  error('Average combining only possible for affine 2-class classifiers')
			  end
			  n = length(a.data);
			  rot = zeros(size(a,1),1);
			  off = 0;
			  for j=1:length(a.data)
				  rot = rot + a.data{j}.data.rot(:,1);
				  off = off + a.data{j}.data.offset(1);
			  end
			  v = affine(rot/n,off/n);			
			otherwise
			  % Standard procedure: make a new trained mapping
			  v = prmapping(mfilename,'trained',{a,type,name,par});
			end
			v = set(v,'size_in',size(a,1),'size_out',size(classlist,1),'labels',classlist);
			v = setcost(v,a);
		end	
		
	elseif isa(a,'prdataset') & isempty(w) 
		
		% Call like v = dataset*fixedcc,
		% Here the work will be done:
		% the dataset has already been mapped through the mappings, and the outputs
		% should be processed according to the combiner type.
		
		% get all the relevant parameters:
		[m,k] = size(a);
		featlist = getfeatlab(a);
		if isempty(featlist)
			prwarning(2,'No class names given: numbering inserted')
			nclass = [1:k]';
			classlist = [1:k]';
		else
			[nclass,classlist] = renumlab(featlist);
		end
		c = size(classlist,1);
		d = zeros(size(a,1),c);
		b = +a;  % the classifier outputs to be processed
		%DXD: I need for my one-class classifiers that the feature domains
		%are retained:
		newfeatdom = getfeatdom(a);
		if ~isempty(newfeatdom)
			newfeatdom = newfeatdom(1:size(d,2));
		end

		% for each of the classes the outputs should now be combined to a new
		% one, using the combining rule:
		for j=1:c
			
			J = find(nclass==j);
			
			switch type
				
			case 'min'
			  d(:,j) = min(b(:,J),[],2);
			  
			case 'max'
			  d(:,j) = max(b(:,J),[],2);
			  
			case 'mean'
			  d(:,j) = mean(b(:,J),2);
			  
			case 'prod'
			  %d(:,j) = prod(b(:,J),2);
				d(:,j) = exp(sum(log(b(:,J)),2));
				
			case 'median'
			  d(:,j) = median(b(:,J),2);
			  
			case 'vote' % Assumes that classifier outcomes are well ordered in b
				% For voting we cannot combine the basic classifier outputs,
				% but we should use the classifier labels:
				n = size(a,2) / c;
				if ~isint(n)
					error('All classifiers should refer to all classes')
				end
				% First get the votes for each of the classes:
				[dummy,fl] = renumlab(featlist);
				mlab = zeros(m,n);
        % we are in a loop over all clases, but we treat here all classes
        % simultaneously and break below. First run over all classifiers
				for j=1:n
					J = [(j-1)*c+1:j*c];
					labels = labeld(a(:,J));
					[dummy,nlab,ll] = renumlab(fl,labels);
					mlab(:,j) = nlab;
				end
				% Then count the number of votes for every class
				for j=1:c
					d(:,j) = (sum(mlab==j,2)+1)/(n+c);
				end
				%DXD: for this voting rule, the feature domain will change:
				for k=1:c
					newfeatdom{k} = [0 inf; 0 inf];
        end
        % and we are done
				break
        
			case 'perc'
				d(:,j) = prctile(b(:,J),par,2);
				
			case 'average'
				error([newline 'Average combiner should directly call the classifiers' ...
				newline 'e.g. A*AVERAGEC([W1 W2 W3]), or A*([W1 W2 W3]*AVERAGEC)'])
				     
			otherwise
			  error(['Unknown method for fixed combining: ' type])
			end
			
		end
		
		v = setdata(a,d,classlist);
		%DXD: I need for my one-class classifiers that the feature domains
		%are retained:
		if ~isempty(newfeatdom)
			v = setfeatdom(v,newfeatdom);
		end
		
		
	elseif (isa(a,'double') || isa(a,'prdataset')) && isa(w,'prmapping')
		
		% call like v = dataset * trained combiner (e.g. a*votec([u v w]))

		% This means that we first have to map the data through the mappings, and
		% then map this new dataset through the combiner:

		if strcmp(getmapping_file(w),mfilename)
			% Then we already have a nice combining rule:
			% get the relevant parameters:
			type = w.data{2};
			name = w.data{3};
			par - w.data{4};
			% Evaluate the mapped data (a*w.data{1}) by this combining rule:
			v = feval(mfilename,a*w.data{1},[],type,name,par);
		else
			% We will use the parameters given in the argument list
			% evaluate the mapped data (a*w) by this combining rule:
			v = feval(mfilename,a*w,[],type,name,par);
		end
		
	else                   % this should not happen
		
		error('Call cannot be parsed')
		
	end

	if isa(v,'prmapping')
		v = setname(v,name);
	end

	return