Project Structure

The implementation consists of several core components:

• main.m - Main script for orchestrating the conversion proces
• get_images.m - Core function handling signal processing and image generation
• axis_control.m - Utility for managing axis display settings
• Algorithms/ - Directory containing specialized transformation algorithms

Supported Transformation Methods

The framework implements 24 different methods for converting 1D data to 2D images, categorized as:

Time-Frequency Analysis Methods

• Mel spectrogram
• Short-time Fourier transform (STFT)
• S-transform
• Wigner-Ville Distribution
• Discrete Wigner-Ville Distribution
• Hilbert-Huang Transform
• Continuous wavelet transform
• Real wavelet transform
• Synchrosqueezing transform
• Wavelet synchrosqueezed transform
• Wavelet second-order synchrosqueezed transform
• Vertical second-order synchrosqueezing
• Multisynchrosqueezing Transform
• Wavelet Multisynchrosqueezed Transform
• Local maximum synchrosqueezing transform
• Time-reassigned Multisynchrosqueezing Transform
• Synchroextracted transform
• Wavelet Synchroextracted Transform
• Transient-extracting transform
• Second-order transient-extracting transform

Transformation Methods

• Gramian angular summation field
• Gramian angular difference field
• Recurrence plots
• Relative Position Matrix

Main Processing Pipeline

The conversion process follows a standardized workflow:

1. Data Preparation

First, we need to prepare a MAT file containing the 1D signal data. The data should be structured as a single vector or matrix.

2. Configuration Setup

The main script allows configuration of key parameters:

%% 1D signal to 2D image experiment
clc; clear; close all

%% 1. Load data → 1D data
load test_data

%% 2. Select method
segment_length = 1024; % Segment size for processing
display_flag = 0; % Axis display control (0=show info, 1=hide info)
method = 'ST'; % Method selection string

%% 3. Define file path for saving images
output_dir = [method '_images']; % Output directory name
if ~exist(output_dir, 'dir')
    mkdir(output_dir);
    fprintf('Created directory: %s\n', output_dir);
end

%% 4. Generate images
addpath(genpath('Algorithms')); % Add algorithm directory to path
get_images(signal_data, segment_length, method, output_dir, display_flag);
rmpath(genpath('Algorithms')); % Remove algorithm path after processing

3. Image Generation

The core processing function get_images handles the signal processing and image generation:

function get_images(signal, segment_size, method, output_path, display_option)
    signal = signal(:); % Ensure column vector format
    num_segments = floor(length(signal) / segment_size); % Calculate number of segments
    
    switch method
        case 'mel'
            % Mel spectrogram parameters
            sample_rate = 5000;
            window_length = 10;
            overlap = 5;
            fft_points = 1024;
            
            for i = 1:num_segments
                segment = signal(1 + segment_size*(i-1) : i*segment_size);
                [spectrogram_data, freq_bins, time_bins] = melSpectrogram(segment, sample_rate, ...
                    'WindowLength', window_length, 'OverlapLength', overlap, 'FFTLength', fft_points);
                spectrogram_data = 10*log10(spectrogram_data + eps); % Convert to dB
                
                imagesc(time_bins, freq_bins, spectrogram_data);
                axis_control(display_option);
                saveas(gcf, fullfile(output_path, [method '_' num2str(i) '.jpg']));
            end
            
        case 'stft'
            % STFT parameters
            sample_rate = 5000;
            window = hamming(10);
            overlap = 5;
            nfft = 1024;
            
            for i = 1:num_segments
                segment = signal(1 + segment_size*(i-1) : i*segment_size);
                [S, F, T] = spectrogram(segment, window, overlap, nfft, sample_rate);
                imagesc(T, F, 20*log10(abs(S)));
                axis_control(display_option);
                saveas(gcf, fullfile(output_path, [method '_' num2str(i) '.jpg']));
            end
            
        % Additional cases for other methods...
    end
    close; % Close figure after processing
end

Detailed Transformation Methods

Mel Spectrogram

The Mel spectrogram converts audio signals into a visual representation that mimics human auditory perception:

case 'mel'
    sample_rate = 5000;
    window_length = 10;
    overlap = 5;
    fft_points = 1024;
    
    for i = 1:num_segments
        segment = signal(1 + segment_size*(i-1) : i*segment_size);
        [spectrogram_data, freq_bins, time_bins] = melSpectrogram(segment, sample_rate, ...
            'WindowLength', window_length, 'OverlapLength', overlap, 'FFTLength', fft_points);
        spectrogram_data = 10*log10(spectrogram_data + eps); % Convert to dB
        
        imagesc(time_bins, freq_bins, spectrogram_data);
        axis_control(display_option);
        saveas(gcf, fullfile(output_path, [method '_' num2str(i) '.jpg']));
    end

Short-time Fourier Transform (STFT)

STFT provides time-localized frequency information:

case 'stft'
    sample_rate = 5000;
    window = hamming(10);
    overlap = 5;
    nfft = 1024;
    
    for i = 1:num_segments
        segment = signal(1 + segment_size*(i-1) : i*segment_size);
        [S, F, T] = spectrogram(segment, window, overlap, nfft, sample_rate);
        imagesc(T, F, 20*log10(abs(S)));
        axis_control(display_option);
        saveas(gcf, fullfile(output_path, [method '_' num2str(i) '.jpg']));
    end

Continuous Wavelet Transform (CWT)

CWT uses wavelets of varying scales to analyze signals:

case 'cwt'
    sample_rate = 5000;
    wavelet_type = 'haar';
    total_scales = 256;
    
    t = 1/sample_rate : 1/sample_rate : 1;
    center_freq = centfrq(wavelet_type);
    cparam = 2 * center_freq * total_scales;
    scales = cparam ./ (total_scales:-1:1);
    
    for i = 1:num_segments
        segment = signal(1 + segment_size*(i-1) : i*segment_size);
        coefficients = cwt(segment, scales, wavelet_type);
        frequencies = scal2frq(scales, wavelet_type, 1/sample_rate);
        
        imagesc(t, frequencies, abs(coefficients));
        axis_control(display_option);
        saveas(gcf, fullfile(output_path, [method '_' num2str(i) '.jpg']));
    end

S-Transform

The S-transform provides a time-frequency representation with phase information:

case 'ST'
    for i = 1:num_segments
        segment = signal(1 + segment_size*(i-1) : i*segment_size);
        [st_matrix, time_axis, freq_axis] = st(segment);
        
        imagesc(time_axis, freq_axis, abs(st_matrix));
        axis_control(display_option);
        saveas(gcf, fullfile(output_path, [method '_' num2str(i) '.jpg']));
    end

Gramian Angular Field (GAF)

GAF converts time series into angular coordinates for image representation:

case 'GASF'
    for i = 1:num_segments
        segment = signal(1 + segment_size*(i-1) : i*segment_size);
        gaf_matrix = GAF(segment, '+', 0);
        
        imagesc(gaf_matrix);
        axis_control(display_option);
        saveas(gcf, fullfile(output_path, [method '_' num2str(i) '.jpg']));
    end
    
case 'GADF'
    for i = 1:num_segments
        segment = signal(1 + segment_size*(i-1) : i*segment_size);
        gaf_matrix = GAF(segment, '-', 0);
        
        imagesc(gaf_matrix);
        axis_control(display_option);
        saveas(gcf, fullfile(output_path, [method '_' num2str(i) '.jpg']));
    end

Recurrence Plot

Recurrence plots visualize the recurrence of states in phase space:

case 'RP'
    embedding_dim = 4;
    time_delay = 1;
    threshold = 0.1;
    
    for i = 1:num_segments
        segment = signal(1 + segment_size*(i-1) : i*segment_size);
        rp_matrix = RecurrencePlot(segment, embedding_dim, time_delay, threshold, 0);
        
        imshow(rp_matrix, []);
        axis_control(display_option);
        saveas(gcf, fullfile(output_path, [method '_' num2str(i) '.jpg']));
    end

Axis Control Utility

The axis_control function manages the display of axes and figure properties:

function axis_control(display_flag)
    image_size = 400;
    if display_flag == 1
        ylabel('Frequency (Hz)');
        xlabel('Time');
    else
        box off; axis off; % Hide frame and axes
        set(gcf, 'Position', [600 100 image_size image_size]);
        set(gca, 'xticklabel', [], 'yticklabel', []);
        set(gca, 'position', [0 0 1 1]); % Remove margins
    end
end

Advanced Algorithms

The Algorithms directory contains specialized implementations for complex transformations:

Wavelet Synchrosqueezed Transform

function [sst, frequencies] = wset(signal, varargin)
    % Wavelet Synchroextracted Transform implementation
    % ... implementation details ...
end

Time-reassigned Multisynchrosqueezing Transform

function [ts, tfr2] = TMSST(signal, window_length, iterations)
    % Time-reassigned Multisynchrosqueezing Transform
    % ... implementation details ...
end

Transient-extracting Transform

function [te_representation] = TET(signal, window_length)
    % Transient-extracting transform implementation
    % ... implementation details ...
end

Usage Example

To use the system, follow these steps:

1. Prepare your 1D signal data in a MAT file
2. Configure the main.m script with your desired parameters
3. Select the transformation method from the supported list
4. Run the script to generate and save 2D images

The output will be saved in a directory named after the selected method (e.g., ST_images/ for S-transform), containing JPG images of the transformed signal representasions.