Lesson 09-Advanced Toolbox Fundamentals

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);
Share your love