La dimensión fractal es una métrica clave para cuantificar la complejidad y la irregularidad de una señal. Su aplicación es común en el análisis de señales biomédicas, diagnóstico de fallos en maquinaria y el estudio de series temporales financieras. A continuación, se describen varios métodos para calcularla, junto con su implementación en MATLAB.

1. Método de Conteo de Cajas (Box Counting)

Principio fundamental

Este método cubre la señal con una red de cuadrículas de diferentes tamaños (escalas). El número de cajas necesarias para cubrir la señal se registra para cada escala. La dimensión fractal se obtiene de la pendiente de la recta que ajusta el logaritmo del número de cajas frente al logaritmo de la escala.

Implementación en MATLAB

function dimensionFractal = calcularDimensionBoxCounting(senal, escalaMin, escalaMax)
    % Parámetros:
    % senal: vector unidimensional de la señal de entrada.
    % escalaMin: escala de caja más pequeña (típicamente 1).
    % escalaMax: escala de caja más grande (ej. 1/10 de la longitud de la señal).
    
    longitudTotal = length(senal);
    vectorEscalas = escalaMin:escalaMax;
    conteoCajas = zeros(size(vectorEscalas));
    
    for idx = 1:length(vectorEscalas)
        tamCajaActual = vectorEscalas(idx);
        totalCajas = 0;
        
        % Definir los bordes en el eje x
        bordesX = 1:tamCajaActual:longitudTotal;
        if bordesX(end) < longitudTotal
            bordesX = [bordesX, longitudTotal];
        end
        
        % Contar las cajas necesarias en cada segmento
        for j = 1:(length(bordesX)-1)
            segmento = senal(bordesX(j):min(bordesX(j+1), longitudTotal));
            valorMinY = min(segmento);
            valorMaxY = max(segmento);
            
            bordesY = valorMinY:tamCajaActual:valorMaxY;
            if bordesY(end) < valorMaxY
                bordesY = [bordesY, valorMaxY];
            end
            
            totalCajas = totalCajas + (length(bordesY) - 1);
        end
        
        conteoCajas(idx) = totalCajas;
    end
    
    % Regresión lineal para encontrar la dimensión
    logEscalas = log(vectorEscalas);
    logConteos = log(conteoCajas);
    indicesValidos = isfinite(logEscalas) & isfinite(logConteos);
    coeficientes = polyfit(logEscalas(indicesValidos), logConteos(indicesValidos), 1);
    dimensionFractal = coeficientes(1);
    
    % Gráfico de verificación
    figure;
    scatter(logEscalas, logConteos, 'filled');
    hold on;
    plot(logEscalas, polyval(coeficientes, logEscalas), 'r-', 'LineWidth', 2);
    xlabel('log(Escala)');
    ylabel('log(Número de Cajas)');
    title(['Dimensión Box Counting: D = ', num2str(dimensionFractal)]);
    grid on;
end

Ejemplo de uso

% Generación de una señal de prueba (movimiento browniano)
puntos = 1000;
senalPrueba = cumsum(randn(1, puntos));

% Cálculo de la dimensión fractal
dimBC = calcularDimensionBoxCounting(senalPrueba, 1, 50);
disp(['Dimensión fractal (Box Counting): ', num2str(dimBC)]);

2. Método de Higuchi (para Series Temporales)

Principio fundamental

Este enfoque construye múltiples sub-series a partir de la señal original con diferentes retrasos temporales. Se calcula la longitud de cada sub-serie y se analiza la relación entre esta longitud y el retraso para estimar la dimensión fractal.

Implementación en MATLAB

function dimFractalHiguchi = calcularDimensionHiguchi(senal, kMax)
    % Parámetros:
    % senal: vector unidimensional de la señal.
    % kMax: máximo retraso temporal (por defecto, 1/10 de la longitud).
    
    N = length(senal);
    if nargin < 2
        kMax = floor(N/10);
    end
    
    longitudL = zeros(1, kMax);
    
    for k = 1:kMax
        acumuladorLk = 0;
        for m = 1:k
            % Construcción de la sub-serie
            indices = m:k:N;
            if length(indices) > 1
                subSerie = senal(indices);
                % Cálculo de la longitud de la curva
                longitudLmk = sum(abs(diff(subSerie))) * (N - 1) / (floor((N - m)/k) * k);
                acumuladorLk = acumuladorLk + longitudLmk;
            end
        end
        longitudL(k) = acumuladorLk / k;
    end
    
    % Regresión lineal
    indicesUtiles = find(longitudL > 0);
    logK = log(1:kMax);
    logL = log(longitudL(indicesUtiles));
    coef = polyfit(logK(indicesUtiles), logL, 1);
    dimFractalHiguchi = -coef(1);
    
    % Gráfico
    figure;
    scatter(logK, logL, 'filled');
    hold on;
    plot(logK, polyval(coef, logK), 'r-', 'LineWidth', 2);
    xlabel('log(k)');
    ylabel('log(L(k))');
    title(['Dimensión de Higuchi: D = ', num2str(dimFractalHiguchi)]);
    grid on;
end

Ejemplo de uso

% Señal de prueba: onda sinusoidal con ruido
tiempo = linspace(0, 10, 1000);
senalConRuido = sin(2*pi*tiempo) + 0.5*randn(1, 1000);

dimHiguchi = calcularDimensionHiguchi(senalConRuido);
disp(['Dimensión fractal (Higuchi): ', num2str(dimHiguchi)]);

3. Algoritmo de Petrosian (Cálculo Rápido)

Principio fundamental

Se basa en la frecuencia de cambio de signo de la derivada (o aproximación) de la señal. Es un método copmutacionalmente eficiente.

Implementación en MATLAB

function dimPetrosian = calcularDimensionPetrosian(senal)
    N = length(senal);
    % Aproximación de la derivada
    derivada = diff(senal);
    % Número de cambios de signo
    cambiosSigno = sum(abs(diff(sign(derivada))) > 0) / 2;
    % Cálculo de la dimensión
    dimPetrosian = log10(N) / (log10(N) + log10(N/(N + 0.4*cambiosSigno)));
end

4. Método de Katz (Basado en Características Globales)

Principio fundamental

Utiliza la longitud total de la trayectoria de la señal y la distancia promedio de los puntos al origen para calcular la dimensión.

Implementación en MATLAB

function dimKatz = calcularDimensionKatz(senal)
    N = length(senal);
    amplitud = max(senal) - min(senal);
    % Longitud total del camino (longitud de la polilínea)
    longitudTotal = sum(sqrt(1 + diff(senal).^2));
    % Distancia promedio al primer punto (origen)
    origen = senal(1);
    distancias = sqrt(( (1:N) - 1 ).^2 + (senal - origen).^2);
    distanciaPromedio = mean(distancias);
    % Cálculo de la dimensión
    dimKatz = log10(N) / (log10(amplitud / longitudTotal) + log10(N));
end

5. Análisis Multifractal

Principio fundamental

Este método estudia la distribución de múltiples exponentes de escala (singularidades) dentro de la señal, proporcionando un espectro de dimensiones (Dq) en lugar de un solo valor.

Implementación en MATLAB (esquemática)

function [espectroDq, tauQ] = analizarMultifractal(senal, valoresQ, escalas)
    % Parámetros:
    % senal: señal de entrada.
    % valoresQ: vector de valores q (ej. -5:0.5:5).
    % escalas: vector de escalas (ej. 2.^(1:6)).
    
    numEscalas = length(escalas);
    numQ = length(valoresQ);
    espectroDq = zeros(1, numQ);
    tauQ = zeros(1, numQ);
    Zq = zeros(numEscalas, numQ);
    
    for i = 1:numEscalas
        escalaActual = escalas(i);
        numSegmentos = floor(length(senal) / escalaActual);
        % Se reorganiza la señal en una matriz
        matrizSegmentos = reshape(senal(1:numSegmentos*escalaActual), escalaActual, numSegmentos);
        
        % Se calcula una medida local (ej. varianza, box-counting local) para cada segmento
        medidaLocal = var(matrizSegmentos); % Ejemplo usando varianza
        
        for j = 1:numQ
            q = valoresQ(j);
            if q == 1
                % Caso especial para q=1 (entropía)
                medidaLocal_q = log(medidaLocal);
            else
                medidaLocal_q = medidaLocal.^q;
            end
            Zq(i, j) = sum(medidaLocal_q);
        end
    end
    
    % Se calcula τ(q) y Dq por regresión
    for j = 1:numQ
        logEscalas = log(escalas);
        logZq = log(abs(Zq(:, j))); % Se usa valor absoluto por si Zq es negativo
        idxValido = isfinite(logZq);
        coef = polyfit(logEscalas(idxValido)', logZq(idxValido), 1);
        tauQ(j) = coef(1);
        qActual = valoresQ(j);
        if qActual == 0
            espectroDq(j) = tauQ(j);
        else
            espectroDq(j) = tauQ(j) / (qActual - 1); % Fórmula general para Dq
        end
    end
    
    % Gráfico del espectro
    figure;
    plot(valoresQ, espectroDq, '-o', 'LineWidth', 1.5);
    xlabel('q');
    ylabel('D(q)');
    title('Espectro de Dimensiones Fractales Generalizadas');
    grid on;
end

Aplicación Ejemplo: Análisis de una Señal de ECG

% Carga de datos (ejemplo conceptual)
% datos = load('ecg_datos.mat'); % Asumiendo un archivo con campo 'senal' y 'fs'
% ecg = detrend(datos.senal);
% ecg = ecg - mean(ecg);
% Para demostración, usamos una señal sintética:
ecg = cumsum(randn(1, 2000)) + sin(linspace(0, 20*pi, 2000));

% Cálculo con diferentes métodos
d1 = calcularDimensionBoxCounting(ecg, 1, 50);
d2 = calcularDimensionHiguchi(ecg);
d3 = calcularDimensionPetrosian(ecg);
d4 = calcularDimensionKatz(ecg);

fprintf('Resultados del Análisis Fractal de la señal ECG:\n');
fprintf('Box Counting: %.4f\n', d1);
fprintf('Higuchi: %.4f\n', d2);
fprintf('Petrosian: %.4f\n', d3);
fprintf('Katz: %.4f\n', d4);

% Análisis multifractal
valoresQ = -5:1:5;
escalas = 2.^(1:5);
[Dq, tauQ] = analizarMultifractal(ecg, valoresQ, escalas);

Guía de Selección de Método

Consideraciones Prácticas

• Preprocesamiento: Es crucial aplicar filtrado, detrending y normalización a los datos brutos antes del cálculo.
• Parámetros: Los rangos de escalas (para Box Counting) y los valores de q (para multifractal) deben ajustarse al tipo y longitud de la señal.
• Validación: Se recomienda comparar resultados obtenidos con al menos dos métodos diferentes.
• Interpretación: Para señales uni-dimensionales (como series temporales), la dimensión fractal suele encontrarse entre 1 y 2.