Advanced Signal Processing Toolbox
Digital Filter Design and Application
Advanced Filter Design Examples:
% Advanced FIR filter design (multi-band filter)
fs = 2000; % Sampling frequency 2kHz
bands = [0 200 300 400 500 600 700 2000]/fs; % Multi-band boundaries
desired = [1 0 1 0 1 0 1]; % Passband/stopband configuration
weights = [1 10 1 10 1 10 1]; % Weights for each band
n = 100; % Filter order
b = firpm(n, bands, desired, weights); % Parks-McClellan algorithm
% Filter frequency response analysis
fvtool(b,1,'Fs',fs,'FrequencyScale','log');
title('Multi-Band FIR Filter Frequency Response');
% Real-time filtering application
t = 0:1/fs:1-1/fs;
x = sin(2*pi*100*t) + 0.5*sin(2*pi*300*t) + 0.3*sin(2*pi*500*t);
y = filter(b,1,x);
% Time-domain waveform comparison
subplot(2,1,1); plot(t,x); title('Original Signal');
subplot(2,1,2); plot(t,y); title('Filtered Signal');
Adaptive Filtering Techniques:
% LMS adaptive filter (system identification)
order = 32; % Filter order
mu = 0.01; % Step size factor
M = 1; % Input signal delay
ha = adaptfilt.lms(order,mu,M);
% Generate reference signal and unknown system output
n = 1000;
x = randn(n,1); % Input signal (white noise)
[v,e] = filter([0.1 0.2 0.3],1,x); % Unknown system (third-order FIR)
[d,~] = filter([0.1 0.2 0.3],1,x); % Desired signal (with noise)
% Adaptive filtering process
[y,e] = filter(ha,x,d);
% Performance evaluation
figure;
subplot(3,1,1); plot(d); title('Desired Signal');
subplot(3,1,2); plot(y); title('Filter Output');
subplot(3,1,3); plot(e); title('Error Signal');
Advanced Spectral Analysis Techniques
Time-Frequency Joint Analysis:
% Wigner-Ville distribution (time-frequency analysis)
fs = 1000; t = 0:1/fs:1-1/fs;
x = cos(2*pi*100*t) + sin(2*pi*150*t.^2); % Non-stationary signal
% Compute Wigner-Ville distribution
[tfr,t,f] = tfrwv(x,1:length(x),length(x),fs);
% Time-frequency plot visualization
imagesc(t,f,abs(tfr));
xlabel('Time (s)'); ylabel('Frequency (Hz)');
colorbar; title('Wigner-Ville Distribution');
% Advanced short-time Fourier transform
window = hamming(128);
noverlap = 120;
nfft = 256;
[s,f,t] = spectrogram(x,window,noverlap,nfft,fs);
% 3D time-frequency plot
surf(t,f,10*log10(abs(s)),'EdgeColor','none');
axis tight; view(0,90);
xlabel('Time (s)'); ylabel('Frequency (Hz)');
title('STFT Time-Frequency Spectrum');
Image Processing Toolbox in Practice
Advanced Image Segmentation Techniques
Deep Learning-Based Image Segmentation:
% Use pre-trained U-Net for medical image segmentation
unet = unetLayers([512 512 1], 2); % Input size 512x512, 2-class segmentation
unet = initializeNetwork(unet);
% Load training data (example)
imds = imageDatastore('images',{'IncludeSubfolders',true,'LabelSource','foldernames'});
pxds = pixelLabelDatastore('labels',classes,labels);
% Data augmentation
augmenter = imageDataAugmenter(...
'RandRotation',[-10 10],...
'RandXReflection',true);
augimds = augmentedImageDatastore([256 256],imds,augmenter);
% Train network
options = trainingOptions('sgdm',...
'InitialLearnRate',1e-4,...
'MaxEpochs',10,...
'MiniBatchSize',4);
net = trainNetwork(augimds,pxds,unet,options);
% Prediction and visualization
I = imread('test_image.png');
[C,scores] = semanticseg(I,net);
B = labeloverlay(I,C,'Colormap',jet(2));
imshow(B); title('Segmentation Result');
Interactive Image Segmentation:
% Use Image Segmenter App for interactive segmentation
img = imread('medical_scan.png');
segmenter(img);
% In the App:
% 1. Use drawing tools to mark foreground/background
% 2. Train GrabCut algorithm
% 3. Export segmentation mask
% 4. Post-processing (morphological operations)
% Command-line equivalent operation
mask = activecontour(rgb2gray(img), mask, 300); % Edge-guided segmentation
stats = regionprops(mask,'Area','BoundingBox');
largest_region = bwareafilt(mask,1); % Extract largest connected region
Image Filtering and Enhancement
Advanced Filtering Techniques:
% Non-local means denoising
img_noisy = im2double(imread('noisy_image.png'));
img_denoised = imnlmfilt(img_noisy,'DegreeOfSmoothing',0.04);
% BM3D denoising (requires Image Processing Toolbox)
img_bm3d = bm3d(img_noisy, 'Basic');
% Contrast enhancement (adaptive histogram equalization)
img_lowcontrast = im2double(imread('low_contrast.png'));
img_enhanced = adapthisteq(img_lowcontrast,'NumTiles',[8 8],'ClipLimit',0.02);
% Multi-scale Retinex enhancement
img_retinex = retinexMSRCR(img_lowcontrast, [15 15 15], 2.2);
Statistics and Machine Learning Toolbox
Advanced Regression Analysis
Nonlinear Regression Modeling:
% Gaussian Process Regression (GPR)
load('regression_data.mat'); % Contains X,y data
% Define kernel function
kernel = exp(-1/2*(pdist2(X,X).^2)); % Squared exponential kernel
% Train GPR model
gprMdl = fitrgp(X,y,'KernelFunction','ardsquaredexponential',...
'OptimizeHyperparameters',{'Sigma','LengthScale'},...
'HyperparameterOptimizationOptions',struct('AcquisitionFunctionName',...
'expected-improvement-plus'));
% Prediction and confidence interval
[xtest,~] = meshgrid(linspace(min(X),max(X),100));
[y_pred, y_sd] = predict(gprMdl,[xtest(:)']);
% Visualization
figure;
plot(X,y,'ko'); hold on;
fill([xtest(:)'; flipud(xtest(:)')], ...
[y_pred - 1.96*y_sd; flipud(y_pred + 1.96*y_sd)], ...
[0.8 0.8 1]);
plot(xtest(:)',y_pred,'r-');
title('Gaussian Process Regression');
Ensemble Learning Methods:
% Random Forest regression
load('housing_data.mat'); % Contains X,y data
% Create Random Forest regressor
numTrees = 100;
template = templateTree('Reproducible',true);
rfMdl = fitrensemble(X,y,'Method','Bag','NumLearningCycles',numTrees,...
'Learners',template);
% Feature importance evaluation
[imp,indices] = predictorImportance(rfMdl);
figure;
bar(imp(indices));
xticklabels(X.Properties.VariableNames(indices));
title('Feature Importance');
% Model prediction
y_pred = predict(rfMdl,X_test);
mse = mean((y_pred - y_test).^2);
Classification Algorithm Comparison
Deep Learning Classifier:
% CNN image classification
layers = [
imageInputLayer([28 28 1])
convolution2dLayer(3,8,'Padding','same')
batchNormalizationLayer
reluLayer
maxPooling2dLayer(2,'Stride',2)
convolution2dLayer(3,16,'Padding','same')
batchNormalizationLayer
reluLayer
maxPooling2dLayer(2,'Stride',2)
fullyConnectedLayer(10)
softmaxLayer
classificationLayer];
% Data loading (example)
[XTrain,YTrain] = digitTrain4DArrayData;
[XTest,YTest] = digitTest4DArrayData;
% Training options
options = trainingOptions('adam',...
'MaxEpochs',10,...
'MiniBatchSize',64,...
'Plots','training-progress');
% Train network
net = trainNetwork(XTrain,YTrain,layers,options);
% Performance evaluation
YPred = classify(net,XTest);
accuracy = mean(YPred == YTest);
Control System Toolbox Application
Modern Control Design
State-Space Model Analysis and Design:
% Create state-space model
A = [-2 -1;1 0];
B = [1;0];
C = [0 1];
D = 0;
sys_ss = ss(A,B,C,D);
% Pole placement
poles = [-3 -4];
K = place(A,B,poles);
% Observer design
poles_obs = [-5 -6];
L = place(A',C',poles_obs)';
% Closed-loop system analysis
sys_cl = ss(A-B*K, B, C, D);
step(sys_cl);
title('State Feedback Control Response');
% LQR optimal control
Q = eye(2);
R = 1;
[K_lqr,S,e] = lqr(A,B,Q,R);
sys_lqr = ss(A-B*K_lqr, B, C, D);
step(sys_lqr);
title('LQR Control Response');
Robust Control Design:
% H-infinity control
P = ss(A,B,C,D);
[K,CL,gamma] = hinfsyn(P,1,1);
step(CL);
title('H-infinity Control Response');
% μ-synthesis design
blk = [sys_ss 0; 0 sys_ss];
[gamma,CL] = musyn(blk,1,1);
Optimization Toolbox in Practice
Mixed-Integer Programming
Production Planning Optimization:
% Define mixed-integer programming problem
f = [4; 3; 5]; % Production cost coefficients
intcon = [1 2 3]; % All variables are integers
A = [1 1 1; 2 1 0]; % Resource constraint matrix
b = [100; 150]; % Resource upper limits
lb = [0; 0; 0]; % Variable lower bounds
ub = []; % No explicit upper bounds
% Solve
[x,fval] = intlinprog(f,intcon,A,b,[],[],lb,ub);
% Result interpretation
fprintf('Product A production quantity: %d\n', x(1));
fprintf('Product B production quantity: %d\n', x(2));
fprintf('Product C production quantity: %d\n', x(3));
fprintf('Minimum cost: %.2f\n', fval);
Global Optimization Application:
% Multimodal function global optimization
fun = @(x) (x(1)^2 + x(2)^2 - 10*cos(2*pi*x(1)) - 10*cos(2*pi*x(2)) + 20);
nvars = 2;
lb = [-5.12; -5.12];
ub = [5.12; 5.12];
% Genetic algorithm configuration
options = optimoptions('ga',...
'PopulationSize',100,...
'MaxGenerations',200,...
'FunctionTolerance',1e-6);
% Execute optimization
[x_ga,fval_ga] = ga(fun,nvars,[],[],[],[],lb,ub,[],options);
% Particle swarm optimization comparison
options_ps = optimoptions('particleswarm',...
'SwarmSize',50,...
'MaxIterations',200);
[x_ps,fval_ps] = particleswarm(fun,nvars,lb,ub,options_ps);
% Result comparison
fprintf('GA optimal solution: fval=%.4f\n', fval_ga);
fprintf('PSO optimal solution: fval=%.4f\n', fval_ps);



