bbopts.m

数学优化工具箱

function opts = bbopts(type,U,P,u);


opts={};
opts.type=type;

opts.epsilon = 0.95;
opts.minwidth = 0.01;
opts.maxrectangle = 50;
opts.e=1000000;
opts.refine = 1; % bounds propogation flag
opts.delta =15;  % initial feasibility start
opts.branch_type=1; 
opts.alpha=0.5;
opts.feasible=1;
opts.maxiter= 200;
opts.gamma_initialize=1;
% sedumi parameters
opts.pars = {};
opts.pars.fid=0; % debugging support
opts.pars.eps=0;
%opts.pars.bigeps=1e-10;


lpoptions=optimset('linprog');
lpoptions = optimset(lpoptions,'MaxIter',1000);
lpoptions= optimset(lpoptions,'Display','off');
lpoptions= optimset(lpoptions,'LargeScale','off');

opts.lpoptions = lpoptions;


opts.n=[];
opts.xbounds = [];
opts.ybounds = [];
opts.branch_array=[];

opts.PointsArray=[];
opts.CameraArray=[];
opts.StructureArray=[];

if strcmp(type,'l1l1_triangle');
    opts.n=length(P);

    opts.branch_array=zeros(opts.n,1);
    if opts.n >=3;
      opts.branch_array(1:3)=1;
    else
      opts.branch_array(1:2)=1;
    end

    opts.branch_array=logical(opts.branch_array);

    opts.PointsArray=u;
    opts.CameraArray=zeros(opts.n,3,4);
    opts.StructureArray = U;
    for i = 1:opts.n;
        camera = P{i};
        % normalization
        camera = camera*1000/norm(camera,'fro');
        
        opts.CameraArray(i,:,:)=camera;
        if 0;
	  u0 = squeeze(opts.CameraArray(i,:,:))*U';
	  if (u0(3) < 0)
            fprintf('negative depth\n');
            squeeze(opts.CameraArray(i,:,:))
            u0
            return;
	  end
	end
    end

    % assuming that the camera has been normalized;
    opts.xbounds = zeros(opts.n,2);opts.xbounds(:,1)=1e-8;opts.xbounds(:,2)=1000;
    opts.ybounds = zeros(opts.n,2);opts.ybounds(:,1)=1e-3;opts.ybounds(:,2)=1e3;
    
elseif strcmp(type,'l1l1_resection');

    opts.n=size(U,1);
 
    ndim = size(U,2);
    opts.branch_array=zeros(opts.n,1);opts.branch_array(2:ndim)=1;
    opts.branch_array=logical(opts.branch_array);
    P0=P{1};
    u1 =P0*U(1,:)';
    P0=P0/u1(end);
    
    opts.P0=P0;
    opts.CameraArray=P0;
   
    % normalization
    opts.PointsTransform = normalize_pts(u');
    opts.StructureTransform = normalize_pts(U');

    
    un = (opts.PointsTransform*u')';
    Un = (opts.StructureTransform*U')';
    
%    keyboard;
    opts.PointsArray=un(:,1:end-1);
    opts.StructureArray=Un(:,1:end-1);
    
    opts.xbounds = zeros(opts.n,2);opts.xbounds(:,1)=1e-10;opts.xbounds(:,2)=10;
    opts.ybounds = zeros(opts.n,2);opts.ybounds(:,1)=1e-4;opts.ybounds(:,2)=10;
    opts.ybounds(1,1:2)=1;
    
end


function T = normalize_pts(pts);
% assumes points in homogeneous coordinates;

[d,n]=size(pts);

T = eye(d);
center = mean(pts,2);
T(1:end-1,end) = -center(1:end-1);

spts=T*pts;
scale = sqrt(d-1)/mean(sqrt(sum(spts(1:d-1,:).*spts(1:d-1,:),1)));
%T(1:d-1,1:end)=T(1:d-1,1:end)*sqrt(d-1)/sqrt(sum(sum((spts(1:d-1,:).*spts(1:d-1,:)),1)));
T(1:d-1,:) = T(1:d-1,:)*scale;