filtdes.m

matlabDigitalSigalProcess内有文件若干

    if isempty(s)
        str = {'<none>'};
    else
        str = {'<none>' s.label};
    end
    [ind,OK] = listdlg('PromptString','Select a spectrum:',...
                  'SelectionMode','single',...
                  'OKString','OK',...
                  'ListString',str);
    if OK
        if ind == 1
            s = [];
        else
            s = s(ind-1);
        end
        ax = ud.Objects.fdax;
        for i=1:length(ax)
            overlay(ax(i),s)
        end
    end
    
%------------------------------------------------------------------------
% filtview('filtmenu')
%  Callback of filter selection popup
%
case 'filtmenu'
    fig = gcbf;
    ud = get(fig,'userdata');
   
    filtMenuString = get(ud.ht.filtMenu,'string');
    newfiltLabel = filtMenuString{get(ud.ht.filtMenu,'value')};
    if strcmp(ud.filt.label,newfiltLabel)
       % no change
        return
    end
   
    f = sptool('Filters',0);  % get selected filters from SPTool
    f = f(find(strcmp(newfiltLabel,{f.label})));
   
    filtdes('setfilt',f,fig)
   
%------------------------------------------------------------------------
%filtdes('autodesignCB')
%  Callback of autodesign check box
case 'autodesignCB'
    fig = findobj('tag','filtdes');
    ud = get(fig,'userdata');
    
    if get(ud.ht.autoDesign,'value')==1
        % auto design turned on
        if strcmp(get(ud.ht.apply,'enable'),'on')
            filtdes('apply')
        end
    end
    
%------------------------------------------------------------------------
%filtdes('modulepopup')
%  callback of module list popup
case 'modulepopup'
    fig = findobj('tag','filtdes');
    ud = get(fig,'userdata');

    newModule = ud.modules{get(gcbo,'value')};
    if strcmp(ud.currentModule,newModule)
        % no change!
        return
    end
    
    ptr = getptr(fig);
    setptr(fig,'watch'), drawnow
    
    [newfilt,errstr] = feval(newModule,'init',ud.filt);
    drawnow
    
    set(fig,ptr{:})
        
    ud = get(fig,'userdata');
    ud.filt = newfilt;
    ud.currentModule = newModule;
    ud.filt.specs.currentModule = ud.currentModule;
        
    ud.filt = importFiltNoLineinfo(ud.filt); 
    set(fig,'userdata',ud)
    sptool('import',ud.filt,1)

    for i = 1:length(ud.Objects.fdspec)
        ud.Objects.fdspec(i).revertvalue = ud.Objects.fdspec(i).value;
    end
    set([ud.ht.revert ud.ht.apply],'enable','off')    

%------------------------------------------------------------------------
%filtdes('clear',fig)
%  deletes all fd objects from filtdes figure
%  SIDE EFFECT: writes userdata of fig
%  fig is optional, found with findobj if omitted
case 'clear'
    if nargin < 2
        fig = findobj('tag','filtdes');
    else
        fig = varargin{2};
    end

    ud = get(fig,'userdata');
    
    % delete all objects of current module:
    delete(ud.Objects.fdspec)
    delete(ud.Objects.fdmeas)
    % lines will be deleted when axes are deleted
    delete(ud.Objects.fdax)
    
%------------------------------------------------------------------------
%filtdes('lineclick')
%  buttondownfcn of an fdline object
%  call appropriate callback and perform vertex or segment drag
case 'lineclick'
    h = varargin{2};
    ax = get(h,'parent');
    fig = get(ax,'parent');
    
    if justzoom(fig)
        return
    end
    ud = get(fig,'userdata');    
    switch ud.pointer
    case 2  % display help for this line
        disp('help for this line!')
        return
    end
    
    lineud = get(h,'userdata');
    
    pt = get(ax,'currentpoint');
    pt = pt(1,1:2);
    xd = get(h,'xdata');
    yd = get(h,'ydata');

    % convert xd and yd to pixel units
    % ASSUMPTION: both xscale and yscale are linear (NOT log)
    xlim = get(ax,'xlim');
    ylim = get(ax,'ylim');
    pos = get(ax,'position');  % assumed in pixels
    xscale = pos(3)/diff(xlim); % number of pixels per x axis units
    yscale = pos(4)/diff(ylim); % number of pixels per y axis units
    
    [vertexFlag,dist,ind,segdist,segind] = ...
        closestpoint(pt,h,xscale,yscale,xd,yd);
        
    if vertexFlag
      % fprintf(1,'line click - vertex %g: (%g,%g); pix dist: %g\n',...
      %    ind,xd(ind),yd(ind),dist)
    else
      % fprintf(1,'line click - segment %g: (%g,%g) to (%g,%g); pix dist: %g\n',...
      %    segind,xd(segind),yd(segind),xd(segind+1),yd(segind+1),segdist)
    end
    
    evalin('base',lineud.buttondownfcn)

    autoDesign = get(ud.ht.autoDesign,'value');
    
    % create object corresponding to this line handle - this will
    % be used when calling module's apply callback
    L.h = h;
    L = fdline(L);

    errstr = '';    
    newfiltFlag = 0;        
    newfilt = ud.filt;
    if vertexFlag
    % handle vertex drag
        if length(lineud.vertexdragmode)>1
            vertexdragmode = lineud.vertexdragmode{ind};
        else
            vertexdragmode = lineud.vertexdragmode{1};
        end
        switch vertexdragmode
        case 'none'
            if ~isempty(lineud.buttonupfcn)
                uiwaitforButtonUp(fig)
                evalin('base',lineud.buttonupfcn)
            end
            return
        case 'lr'
            cx = 0;  % "constrain x"
            cy = 1;  % "constrain y"
        case 'ud'
            cx = 1;
            cy = 0;
        case 'both'
            cx = 0;
            cy = 0;
        end
        
        if length(lineud.vertexdragcallback)>1
            vertexdragcallback = lineud.vertexdragcallback{ind};
        else
            vertexdragcallback = lineud.vertexdragcallback{1};
        end

        global fd_line_motion_message
        save_wbmf = get(fig,'windowbuttonmotionfcn');
        set(fig,'windowbuttonmotionfcn',...
           ['global fd_line_motion_message, fd_line_motion_message = '...
            '''motion''; uiresume'] );
        set(fig,'windowbuttonupfcn',...
           ['global fd_line_motion_message, fd_line_motion_message = '...
            '''up''; uiresume']);

        done = 0;
        while ~done
            uiwait(fig)
            switch fd_line_motion_message
            case 'motion'
                pt_new = get(ax,'currentpoint');
                xd = get(h,'xdata');
                yd = get(h,'ydata');
                L.delayrender = 'on';
                if ~cx & (pt_new(1,1) ~= xd(ind))
                    xd(ind) = pt_new(1,1);
                    set(L,'xdata',xd)
                end
                if ~cy & (pt_new(1,2) ~= yd(ind))
                    yd(ind) = pt_new(1,2);
                    set(L,'ydata',yd)
                end
                evalin('base',vertexdragcallback)
                if autoDesign
                    % design filter!
                    oldptr = getptr(fig);   
                    setptr(fig,'watch') 
                    [newfilt, errstr] = fdutil('callModuleApply',...
                                        ud.currentModule,newfilt,...
                                       'motion',L);
                    if isempty(errstr) & ~isequal(ud.filt,newfilt)
                        newfiltFlag = 1;
                        set([ud.ht.revert ud.ht.apply],'enable','off')
                    elseif ~isempty(errstr)
                        break
                    end
                    set(fig,oldptr{:}) 
                end
                L.delayrender = 'off';
            case 'up'
                done = 1;
            end
        end
        
        if ~autoDesign  % don't need to design if last motion function
                        % already did so
            % design filter
            oldptr = getptr(fig);   
            setptr(fig,'watch') 
            [newfilt, errstr] = fdutil('callModuleApply',...
                                   ud.currentModule,newfilt,'up',L);
            if isempty(errstr) & ~isequal(ud.filt,newfilt)
                newfiltFlag = 1;
                set([ud.ht.revert ud.ht.apply],'enable','off')    
            end
            set(fig,oldptr{:}) 
        end
        
        if length(lineud.vertexenddragcallback)>1
            vertexenddragcallback = lineud.vertexenddragcallback{ind};
        else
            vertexenddragcallback = lineud.vertexenddragcallback{1};
        end
        evalin('base',vertexenddragcallback)
        
        set(fig,'windowbuttonmotionfcn',save_wbmf)
        set(fig,'windowbuttonupfcn','')
        clear global fd_line_motion_message
    else
    % handle segment drag
        if length(lineud.segmentdragmode)>1
            segmentdragmode = lineud.segmentdragmode{segind};
        else
            segmentdragmode = lineud.segmentdragmode{1};
        end
        switch segmentdragmode
        case 'none'
            if ~isempty(lineud.buttonupfcn)
                uiwaitforButtonUp(fig)
                evalin('base',lineud.buttonupfcn)
            end
            return
        case 'lr'
            cx = 0;  % "constrain x"
            cy = 1;  % "constrain y"
        case 'ud'
            cx = 1;
            cy = 0;
        case 'both'
            cx = 0;
            cy = 0;
        end
        
        if length(lineud.segmentdragcallback)>1
            segmentdragcallback = lineud.segmentdragcallback{segind};
        else
            segmentdragcallback = lineud.segmentdragcallback{1};
        end

        global fd_line_motion_message
        save_wbmf = get(fig,'windowbuttonmotionfcn');
        set(fig,'windowbuttonmotionfcn',...
           ['global fd_line_motion_message, fd_line_motion_message = '...
            '''motion''; uiresume'] );
        set(fig,'windowbuttonupfcn',...
           ['global fd_line_motion_message, fd_line_motion_message = '...
            '''up''; uiresume']);

        % find place along line segment
        % assume that line segment's length and slope will not
        % change during drag
        seg_x = xd(segind+[0 1]);
        if isnan(diff(seg_x)) % Avoid math on NaN; causes warnings on PCWIN
            alfa_x = 1;
        elseif diff(seg_x)~=0
            alfa_x = (pt(1,1)-seg_x(1))/(diff(seg_x));
            alfa_x = max(0,min(alfa_x,1));
        else
            alfa_x = 0;
        end
        seg_y = yd(segind+[0 1]);
        if isnan(diff(seg_y)) % Avoid math on NaN; causes warnings on PCWIN
            alfa_y = 1;
        elseif diff(seg_y)~=0
            alfa_y = (pt(1,2)-seg_y(1))/(diff(seg_y));
            alfa_y = max(0,min(alfa_y,1));
        else
            alfa_y = 0;
        end

        if (alfa_x==0) & (alfa_y==0)
            % Avoid dividing by zero; causes warnings on PCWIN.  Also, alfa
            % can't be NaN - if alfa = NaN the passband specs line will
            % become invisible (data set to NaNs) which causes Rp=NaN.
            alfa = 0;
        else
            alfa = sqrt(alfa_x^2 + alfa_y^2)/sqrt(sum([alfa_x>0 alfa_y>0]));
        end        
    
        done = 0;
        while ~done
            uiwait(fig)
            switch fd_line_motion_message
            case 'motion'
                pt_new = get(ax,'currentpoint');
                xd = get(h,'xdata');
                yd = get(h,'ydata');
                seg_x = xd(segind+[0 1]);
                seg_y = yd(segind+[0 1]);
                % find point on current segment that is alfa between 
                % the first point of the segment and second point
                pt = (1-alfa)*[seg_x(1) seg_y(1)] + alfa*[seg_x(2) seg_y(2)];
                L.delayrender = 'on';
                if ~cx & (pt_new(1,1) ~= pt(1,1))
                    xd(segind+[0 1]) = seg_x + pt_new(1,1) - pt(1,1);
                    set(L,'xdata',xd)
                end
                if ~cy & (pt_new(1,2) ~= pt(1,2))
                    yd(segind+[0 1]) = seg_y + pt_new(1,2) - pt(1,2);
                    set(L,'ydata',yd)
                end
                evalin('base',segmentdragcallback)
                if autoDesign
                    % design filter!
                    oldptr = getptr(fig);   
                    setptr(fig,'watch') 
                    [newfilt, errstr] = fdutil('callModuleApply',...
                                        ud.currentModule,newfilt,...
                                        'motion',L);
                    if isempty(errstr) & ~isequal(ud.filt,newfilt)
                        newfiltFlag = 1;
                        set([ud.ht.revert ud.ht.apply],'enable','off')    
                    elseif ~isempty(errstr)
                        break