(Traitement d'images numériques MATLAB+Python) Chapitre 12 Codage d'images - Sections 1 et 2 : Théorie de base du codage d'images et du codage sans perte

Annuaire d'articles

1 : Théorie de base du codage d’images
2 : Encodage par compression sans perte des images

1 : Théorie de base du codage d’images

Encodage d'image : Processus de conversion d'une image numérique en une représentation compressée. Son objectif est de réduire l'espace de stockage des données d'image et de réduire les besoins en bande passante et en stockage lors de la transmission ou du stockage. Il est principalement divisé en deux catégories.

Compression sans perte : conservez autant que possible toutes les informations de l'image originale pour obtenir une compression sans distorsion. L'un des algorithmes les plus courants est le codage JPEG sans perte (JPEG-LS), qui utilise une transformation en cosinus discrète similaire au JPEG avec perte mais conserve tous les détails.
Compression avec perte : obtenir des taux de compression plus élevés en sacrifiant certains détails et la qualité de l'image. L’un des algorithmes de compression avec perte les plus courants est le codage JPEG (Joint Photographic Experts Group). JPEG utilise la transformation en cosinus discrète (DCT) pour diviser l'image en un spectre de différentes fréquences et réduire les détails à haute fréquence en fonction des caractéristiques de perception de la couleur et de la luminosité de l'œil humain. Cela peut réduire considérablement la taille de l’image, mais introduira un certain degré de distorsion.

(1) La nécessité de la compression d'image

La nécessité de la compression d'image :

Gains d'espace de stockage : Les images numériques brutes occupent souvent beaucoup d'espace de stockage. En compressant les images, vous pouvez réduire efficacement l’espace de stockage qu’elles occupent. Par exemple, une image couleur haute résolution peut nécessiter des centaines de mégaoctets d'espace de stockage, tandis que la compression peut la réduire à des dizaines de mégaoctets ou moins.
Efficacité de transmission améliorée : pour les images qui doivent être transmises sur le réseau, les fichiers d'images plus volumineux prendront plus de bande passante et de temps de transmission. En compressant les images, les coûts de bande passante et de temps nécessaires à la transmission peuvent être considérablement réduits. Ceci est très important pour des applications telles que le partage d'images en ligne, le streaming vidéo, etc.
Utilisation optimale des ressources : Dans des environnements aux ressources limitées tels que les appareils mobiles, les drones, les caméras de surveillance, etc., la compression des images peut réduire les ressources informatiques et la consommation d'énergie nécessaires au traitement et à la transmission. Cela permet de prolonger la durée de vie de la batterie de votre appareil, d'augmenter la vitesse de traitement et de réduire les coûts matériels.

Par exemple, un film couleur de 90 minutes est projeté à 24 images par seconde. Numérisez-le, chaque image a 512´512 pixels, et les trois composantes R, G et B de chaque pixel représentent respectivement 8b, alors le nombre total de bits est

$90 \times 60 \times 24 \times 3 \times 512 \times 512 \times 8 bits_= 97, 200 Mo$

Par conséquent, les limitations en matière de bande passante de transmission, de vitesse et de capacité de mémoire rendent nécessaire la compression des données d'image.

Insérer la description de l'image ici

(2) Possibilité de compression d'image

A : Redondance du codage

Redondance de codage : appelée redondance d'entropie de l'information. Si le codage en niveaux de gris d'une image utilise plus de symboles de codage que ce qui est réellement nécessaire , on dit que l'image contient une redondance de codage \

Par exemple, dans la figure ci-dessous, si 8 bits sont utilisés pour représenter les pixels de l’image, alors l’image est considérée comme ayant une redondance de codage. Les pixels de cette image n'ayant que deux niveaux de gris , ils peuvent être représentés par 1 bit.

Insérer la description de l'image ici

Dans la plupart des images, la distribution des valeurs de gris des pixels de l'image est inégale . Par conséquent, si la valeur de gris de l'image est directement codée en codage binaire naturel (codage de longueur égale), la valeur avec la probabilité maximale et minimale sera attribuée. nombre de bits, ce qui entraîne une redondance du codage

Insérer la description de l'image ici

Lors de l'utilisation d'un codage binaire naturel, la probabilité d'apparition de la valeur de gris des pixels n'est pas prise en compte. Seule l’attribution de longueurs de codage en fonction de la probabilité constitue la méthode de codage la plus simple. Autrement dit, les niveaux de gris ayant une forte probabilité d'apparition sont représentés par des codes courts, et les niveaux de gris ayant une faible probabilité d'apparition sont représentés par des codes longs, ce qui peut réduire la longueur totale du code.

Insérer la description de l'image ici

B : Redondance inter-pixels

Redondance inter-pixels : Il existe généralement une corrélation entre les pixels correspondant aux cibles de l'image . Il existe donc généralement une redondance des données dans les images qui est directement liée à la corrélation entre pixels - redondance de corrélation des pixels. Il y a

Redondance spatiale : Il existe une forte corrélation entre la distribution des niveaux de gris des pixels adjacents
Redondance inter-fréquence : Il existe une forte corrélation en niveaux de gris entre les pixels correspondants de chaque image de bande spectrale dans l'image multispectrale.
Redondance temporelle : Il existe une forte corrélation entre les niveaux de gris des pixels correspondants entre les images de l'image séquence.
Redondance structurelle : Certaines images ont des structures de texture fortes ou une auto-similarité, comme les papiers peints, les nattes de paille, etc.
Redondance des connaissances : certaines images contiennent des informations liées à certaines connaissances préalables

Insérer la description de l'image ici

C : Redondance psychovisuelle

Redondance psychovisuelle : Les yeux humains ne sont pas également sensibles à toutes les informations. Certaines informations ne sont pas aussi importantes que d'autres dans le processus normal de perception visuelle . Ces informations peuvent être considérées comme une redondance psychologique visuelle. reste

(3) Classification des méthodes de compression d'images

A : Classification basée sur le degré de rétention des informations avant et après le codage

Codage préservant les informations (codage sans perte) : garantissant que les informations de l'image ne sont pas perdues pendant le processus de codage et de décodage. Habituellement, le taux de compression ne dépasse pas 3:1.
Codage de fidélité (codage avec perte) : supprimez certaines informations secondaires insensibles à l'œil humaincompressez l'image au maximum selon certaines directives de fidélité.
Extraction de fonctionnalités : dans la reconnaissance d'images, l'analyse, la classification et d'autres technologies, seules les fonctionnalités d'intérêt sont codées et compressées.

B : Classification basée sur la méthode de codage

Codage entropique : Une technologie de codage basée sur les caractéristiques statistiques de l'information . Tels que le codage de longueur de course, le codage de Huffman et le codage arithmétique, etc.
Codage prédictif : méthodes de codage prédictif de modulation par impulsion différentielle et d'estimation et de compensation de mouvement couramment utilisées
Codage de transformation : mappez l'image du domaine spatial sur un autre domaine de transformation via une transformation orthogonale , puis utilisez la quantification et le codage entropique appropriés pour compresser efficacement l'image . Transformations couramment utilisées : transformée de Fourier discrète (DFT), transformée en cosinus discrète (DCT), transformée en ondelettes discrètes (DWT), etc.

C : Autres méthodes

Méthodes de codage précoces : telles que le codage hybride, la quantification vectorielle, l'algorithme LZW, etc.
Quelques nouvelles méthodes de codage
- Codage par compression du réseau de neurones artificiels ANN
- Codage fractal
- codage par ondelettes
- codage par compression basé sur un modèle
- codage par compression basé sur les objets
- …

(4) Terminologie de codage d'images

Taux de compression :

$r=\frac{n}{\bar{L}}=\frac{\text { Le nombre moyen de bits par pixel avant compression Le nombre moyen de bits occupés par chaque pixel}}{\text {Le nombre moyen de bits occupés par chaque pixel après compression}}$

Entropie des images :

令 $p(d_{i})$ est l'image numérique $je$ niveaux de gris $d_{i}$ La probabilité d'occurrence

$H=-\sum_{i=1}^{m} p\left(d_{i}\right) \log _{2} p\left(d_{i}\right)\left(p^{pixel} /{ }_{bit}\right)$

Longueur moyenne du mot de passe $\bar{L}$ ：

令 $L_{i}$ pour les images numériques $je$ niveaux de gris $d_{i}$ La longueur de codage de

$\bar{L}=\sum_{i=1}^{m} L_{i} p\left(d_{i}\right) \quad(\text { pixel } / \text { bit })$

Efficacité du codage :

$\eta=\frac{H}{\bar{L}} \times 100 \%$

2 : Encodage par compression sans perte des images

(1) Théorie du codage sans perte

Théorème de codage sans distorsion de Shannon : également connu sous le nom de théorème de codage source de Shannon, est un théorème important de la théorie de l'information, proposé par Claude Shannon en 1948. Ce théorème montre que, sous une distribution de probabilité discrète donnée, pour toute longueur de code moyenne inférieure à une valeur d'entropie positive, il existe une méthode de codage qui peut amener la longueur de données codées à se rapprocher de cette longueur de code moyenne, et ne sera pas introduite lors du décodage. ... toute distorsion . En bref, le théorème de codage sans distorsion de Shannon montre que pour les sources discrètes avec une certaine distribution de probabilité, nous pouvons concevoir un schéma de codage pour rendre les données codées aussi compactes que possible et proches de leur valeur d'entropie. Lors du décodage, nous pouvons récupérer complètement le message original sans aucune perte ni distorsion d'informations. Ce théorème a une valeur d'application importante dans le domaine de la compression de l'information.Il fournit une base théorique et une idée algorithmique pour compresser efficacement les données et restaurer les informations d'origine lors de la décompression. Dans le même temps, le théorème du codage sans distorsion fournit également une référence et des conseils importants pour d’autres recherches et applications liées à la théorie de l’information.

Comme suit, supposons qu'il existe une séquence de symboles originale telle que

$a_{1}a_{4}a_{4}a_{1}a_{2} a_{1}a_{1}a_{4}a_{1}a_{3}a_{2}a_{1}a_{4}a_{1}a_{1}$

Si un codage de longueur égale est utilisé, le codage de longueur égale traite tous les symboles comme des événements également probables.

Insérer la description de l'image ici

Si un codage à longueur de mot variable est utilisé, la longueur du mot de code de chaque symbole change avec la probabilité d'apparition du caractère.

$une_{1}$ :8 fois
$une_{2}$ :2 fois
$une_{3}$ :Une fois
$un_{4}$ : 4 fois

Insérer la description de l'image ici

(2) Codage de Huffman

R : Aperçu

Cette partie ne sera pas présentée en détail, veuillez passer au (Structure des données de l'examen d'entrée de troisième cycle Wangdao 408) Chapitre 5 Arbre-Section 4 3 : Concepts de base, structure et codage de Huffman de l'arbre de Huffman

B：Programme

Implémenter le codage Huffman des images

matlab：

clc;clear;
%load image
Image=[7 2 5 1 4 7 5 0; 5 7 7 7 7 6 7 7; 2 7 7 5 7 7 5 4; 5 2 4 7 3 2 7 5;
       1 7 6 5 7 6 7 2; 3 3 7 3 5 7 4 1; 7 2 1 7 3 3 7 5; 0 3 7 5 7 2 7 4];
[h w]=size(Image);   totalpixelnum=h*w;
len=max(Image(:))+1;
for graynum=1:len
    gray(graynum,1)=graynum-1;%将图像的灰度级统计在数组gray第一列
end
%将各个灰度出现的频数统计在数组histgram中
for graynum=1:len
    histgram(graynum)=0;    gray(graynum,2)=0;
    for i=1:w
        for j=1:h
            if gray(graynum,1)==Image(j,i)
                histgram(graynum)=histgram(graynum)+1;
            end
        end
    end
    histgram(graynum)=histgram(graynum)/totalpixelnum;
end
histbackup=histgram;
%找到概率序列中最小的两个，相加，依次增加数组hist的维数，存放每一次的概率和，同时将原概率屏蔽（置为1.1）；
%最小概率的序号存放在tree第一列中，次小的放在第二列
sum=0;     treeindex=1;
while(1)
    if sum>=1.0
        break;
    else
        [sum1,p1]=min(histgram(1:len));   histgram(p1)=1.1;
        [sum2,p2]=min(histgram(1:len));   histgram(p2)=1.1;
        sum=sum1+sum2;                len=len+1;          histgram(len)=sum;
        tree(treeindex,1)=p1;         tree(treeindex,2)=p2;
        treeindex=treeindex+1;        
    end
end
%数组gray第一列表示灰度值，第二列表示编码码值，第三列表示编码的位数
for k=1:treeindex-1
    i=k;    codevalue=1;
    if or(tree(k,1)<=graynum,tree(k,2)<=graynum)
        if tree(k,1)<=graynum
            gray(tree(k,1),2)=gray(tree(k,1),2)+codevalue;
            codelength=1;
            while(i<treeindex-1)
                codevalue=codevalue*2;
                for j=i:treeindex-1
                    if tree(j,1)==i+graynum
                        gray(tree(k,1),2)=gray(tree(k,1),2)+codevalue;
                        codelength=codelength+1;
                        i=j;      break;
                    elseif tree(j,2)==i+graynum
                        codelength=codelength+1;
                        i=j;      break;
                    end
                end
            end
            gray(tree(k,1),3)=codelength;
        end
        i=k;    codevalue=1;
        if tree(k,2)<=graynum
            codelength=1;
            while(i<treeindex-1)
                codevalue=codevalue*2;
                for j=i:treeindex-1
                    if tree(j,1)==i+graynum
                        gray(tree(k,2),2)=gray(tree(k,2),2)+codevalue;
                        codelength=codelength+1;
                        i=j;      break;
                    elseif tree(j,2)==i+graynum
                        codelength=codelength+1;
                        i=j;   break;
                    end
                end
            end
            gray(tree(k,2),3)=codelength;
        end
    end
end
%把gray数组的第二三列，即灰度的编码值及编码位数输出
for k=1:graynum
    A{
    
    k}=dec2bin(gray(k,2),gray(k,3));
end
disp('编码');
disp(A);

python：

import numpy as np
import matplotlib.pyplot as plt

# Load image
Image = np.array([[7, 2, 5, 1, 4, 7, 5, 0],
                  [5, 7, 7, 7, 7, 6, 7, 7],
                  [2, 7, 7, 5, 7, 7, 5, 4],
                  [5, 2, 4, 7, 3, 2, 7, 5],
                  [1, 7, 6, 5, 7, 6, 7, 2],
                  [3, 3, 7, 3, 5, 7, 4, 1],
                  [7, 2, 1, 7, 3, 3, 7, 5],
                  [0, 3, 7, 5, 7, 2, 7, 4]])

h, w = Image.shape
totalpixelnum = h * w
len = np.max(Image) + 1

gray = np.zeros((len, 3))
gray[:, 0] = np.arange(len)

histgram = np.zeros(len)
for graynum in range(len):
    histgram[graynum] = np.sum(Image == graynum) / totalpixelnum

histbackup = histgram.copy()

sum_val = 0
treeindex = 0
tree = np.zeros((len, 2))
while True:
    if sum_val >= 1.0:
        break
    else:
        p1 = np.argmin(histgram)
        histgram[p1] = 1.1
        p2 = np.argmin(histgram)
        histgram[p2] = 1.1
        sum_val = histbackup[p1] + histbackup[p2]
        len += 1
        histgram[len-1] = sum_val
        tree[treeindex, 0] = p1
        tree[treeindex, 1] = p2
        treeindex += 1

gray[:, 1] = np.arange(len)

for k in range(treeindex):
    i = k
    codevalue = 1
    if tree[k, 0] <= graynum or tree[k, 1] <= graynum:
        if tree[k, 0] <= graynum:
            gray[int(tree[k, 0]), 1] += codevalue
            codelength = 1
            while i < treeindex - 1:
                codevalue *= 2
                for j in range(i, treeindex - 1):
                    if tree[j, 0] == i + graynum:
                        gray[int(tree[k, 0]), 1] += codevalue
                        codelength += 1
                        i = j
                        break
                    elif tree[j, 1] == i + graynum:
                        codelength += 1
                        i = j
                        break
            gray[int(tree[k, 0]), 2] = codelength

        i = k
        codevalue = 1
        if tree[k, 1] <= graynum:
            codelength = 1
            while i < treeindex - 1:
                codevalue *= 2
                for j in range(i, treeindex - 1):
                    if tree[j, 0] == i + graynum:
                        gray[int(tree[k, 1]), 1] += codevalue
                        codelength += 1
                        i = j
                        break
                    elif tree[j, 1] == i + graynum:
                        codelength += 1
                        i = j
                        break
            gray[int(tree[k, 1]), 2] = codelength

# Convert gray code to binary strings
A = [bin(int(x[1]))[2:].zfill(int(x[2])) for x in gray[:len]]

# Display the encoding
print("编码:")
for i, code in enumerate(A):
    print(f"{
      
      i}: {
      
      code}")

# Plotting the image
plt.imshow(Image, cmap='gray')
plt.axis('off')
plt.show()

(3) Codage arithmétique

R : Aperçu

Codage arithmétique : il s'agit d'une technique de compression de données sans distorsion utilisée pour convertir des séquences de données source en séquences codées plus compactes . Contrairement aux méthodes traditionnelles de codage de longueur fixe (telles que le codage de Huffman), le codage arithmétique utilise un intervalle pour représenter l'intégralité de la séquence de données source, plutôt que de mapper chaque symbole sur un mot de code de longueur fixe. L'idée de base du codage arithmétique est d'utiliser la distribution de probabilité d'apparition des symboles pour attribuer un intervalle correspondant à chaque symbole et de réduire progressivement la plage d'intervalles en fonction de la séquence de symboles d'entrée. Enfin, toute valeur comprise dans l'intervalle généré peut représenter le code unique de la séquence de données d'origine. Les étapes de base sont les suivantes

Initialisation : Étant donné la séquence de symboles à coder et la distribution de probabilité correspondante.
Créer des intervalles initiaux : attribuez à chaque symbole un intervalle en fonction de sa distribution de probabilité.
Encodage : En fonction de chaque symbole d'entrée, mettez à jour les limites supérieure et inférieure de l'intervalle en fonction de son rapport de longueur dans l'intervalle actuel.
Recalibrage : En fonction de la mise à jour de l'intervalle, un recalibrage est effectué pour garantir la précision et éviter les débordements.
Sortie : lorsque tous les symboles sont codés, toute valeur codée dans l'intervalle final est sortie comme résultat de la compression.

L'avantage du codage arithmétique est qu'il peut atteindre un taux de compression proche de l'efficacité du codage entropique, ce qui est particulièrement adapté aux données avec une distribution de probabilité de symbole inégale et une fréquence élevée. Cependant, la mise en œuvre du codage arithmétique est relativement complexe et nécessite beaucoup de calculs, et nécessite une grande précision dans le processus de décodage. Il convient de noter que, étant donné que le codage arithmétique implique des opérations sur nombres à virgule flottante et un traitement de précision, il peut y avoir certains problèmes d'accumulation d'erreurs et d'erreurs d'arrondi dans les applications pratiques. Ces problèmes peuvent être atténués en utilisant des représentations numériques de plus grande précision ou en employant d'autres techniques. En bref, le codage arithmétique est une technologie de compression de données puissante qui peut fournir un taux de compression élevé, particulièrement adapté à la compression sans perte et aux scénarios nécessitant un taux de compression élevé.

B：Programme

matlab：

%算术编码
clc;clear;
%load image
%Image=[7 2 5 1 4 7 5 0;5 7 7 7 7 6 7 7;2 7 7 5 7 7 5 4;5 2 4 7 3 2 7 5;
%       1 7 6 5 7 6 7 2;3 3 7 3 5 7 4 1;7 2 1 7 3 3 7 5;0 3 7 5 7 2 7 4];
Image=[4 1 3 1 2];   
[h w col]=size(Image);   pixelnum=h*w;
graynum=max(Image(:))+1;
for i=1:graynum
    gray(i)=i-1;
end
histgram=zeros(1,graynum);
for i=1:w
    for j=1:h
        pixel=uint8(Image(j,i)+1);
        histgram(pixel)=histgram(pixel)+1;          
    end    
end
histgram=histgram/pixelnum;%将各个灰度出现的频数统计在数组histgram中
disp('灰度级');disp(num2str(gray));
disp('概率');disp(num2str(histgram))
disp('每一行字符串及其左右编码：')
for j=1:h
    str=num2str(Image(j,:));    left=0;    right=0;
    intervallen=1;              len=length(str);
    for i=1:len
        if str(i)==' '
            continue;
        end
        m=str2num(str(i))+1;      pl=0;        pr=0;
        for j=1:m-1
            pl=pl+histgram(j);
        end
        for j=1:m
            pr=pr+histgram(j);
        end
        right=left+intervallen*pr; left=left+intervallen*pl;%间隔区间起始和终止端点           
        intervallen=right-left; %  间隔区间宽度     
    end
    %输入图像信息数据
    disp(str);  
    %编码输出间隔区间
    disp(num2str(left));  disp(num2str(right))    
    temp=0;  a=1;
    while(1)
        left=2*left;
        right=2*right;
    if floor(left)~=floor(right)
        break;
    end
    temp=temp+floor(left)*2^(-a);
    a=a+1;
    left=left-floor(left);
    right=right-floor(right);
    end
    temp=temp+2^(-a);
    ll=a;
    %寻找最后区间内的最短二进制小数和所需的比特位数
    disp(num2str(temp));  disp(ll);    
    %算术编码的编码码字输出：
    disp('算术编码的编码码字输出：'); 
    %yy=DEC2bin(temp,ll);
    %简单的将10进制转化为N为2进制小数
    for ii= 1: ll
        temp1=temp*2;
        yy(ii)=floor(temp1);
        temp=temp1-floor(temp1);
    end
    disp(num2str(yy));    
end

python：

import numpy as np

# 算术编码
# load image
Image = np.array([[4, 1, 3, 1, 2]])
[h, w] = Image.shape
pixelnum = h * w
graynum = np.max(Image) + 1

gray = np.arange(graynum)

histgram = np.zeros(graynum)
for i in range(w):
    for j in range(h):
        pixel = Image[j, i]
        histgram[pixel] += 1

histgram /= pixelnum
print('灰度级:', gray)
print('概率:', histgram)

print('每一行字符串及其左右编码：')
for j in range(h):
    str_ = [str(x) for x in Image[j]]
    left = 0
    right = 0
    intervallen = 1
    len_ = len(str_)
    for i in range(len_):
        if str_[i] == ' ':
            continue
        m = int(str_[i]) + 1
        pl = np.sum(histgram[:m-1])
        pr = np.sum(histgram[:m])
        right = left + intervallen * pr
        left = left + intervallen * pl
        intervallen = right - left
    
    print(''.join(str_))
    print(left, right)
    
    temp = 0
    a = 1
    while True:
        left *= 2
        right *= 2
        if int(left) != int(right):
            break
        temp += int(left) * pow(2, -a)
        a += 1
        left -= int(left)
        right -= int(right)
    
    temp += pow(2, -a)
    ll = a
    
    print(temp, ll)
    
    print('算术编码的编码码字输出：')
    yy = []
    for ii in range(ll):
        temp1 = temp * 2
        yy.append(int(temp1))
        temp = temp1 - int(temp1)
    
    print(yy)

(4) Codage LZW

R : Aperçu

** Encodage LZW : Il s'agit d'un algorithme de compression sans perte utilisé pour la compression des données. Il peut encoder des modèles répétés dans les données d'entrée en codes plus courts, réduisant ainsi l'espace de stockage des données . Le codage LZW a été initialement proposé par Terry Welch en 1984 et est largement utilisé dans des domaines tels que les images, l'audio et le texte. L'idée de base du codage LZW est d'utiliser un dictionnaire pour coder les données d'entrée. Initialement, le dictionnaire contient tous les caractères uniques possibles comme clés et les nombres correspondants comme valeurs. Ensuite, en commençant par le début des données d'entrée, les données d'entrée sont analysées étape par étape et en vérifiant si la séquence actuellement analysée existe déjà dans le dictionnaire. S'il existe déjà, continuez à parcourir en arrière et à assembler la séquence actuelle avec le caractère suivant jusqu'à ce qu'une nouvelle séquence soit trouvée. A ce moment, le numéro de la nouvelle séquence est affiché et la nouvelle séquence est ajoutée au dictionnaire pour un codage ultérieur. L'ensemble du processus se poursuit jusqu'à ce que l'intégralité des données d'entrée ait été analysée. La clé du codage LZW est de maintenir un dictionnaire mis à jour dynamiquement. Au cours du processus de codage, le dictionnaire s'agrandit et est mis à jour en fonction des modèles présents dans les données d'entrée. Par conséquent, les mêmes données d'entrée peuvent être représentées en utilisant des codages de différentes longueurs, avec des taux de compression plus élevés.

B：Programme

matlab：

clc;clear;
Image=[30 30 30 30;110 110 110 110;
       30 30 30 30;110 110 110 110];
[h w col]=size(Image);
pixelnum=h*w;     graynum=256;
%graynum=max(Image(:))+1;
if col==1    
    graystring=reshape(Image',1,pixelnum);%灰度图像从二维变为一维信号
    for tablenum=1:graynum
        table{
    
    tablenum}=num2str(tablenum-1);
    end
    len=length(graystring);   lzwstring(1)=graynum;
    R='';         stringnum=1;
    for i=1:len
        S=num2str(graystring(i));
        RS=[R,S];      flag=ismember(RS,table);
        if flag
            R=RS;
        else
            lzwstring(stringnum)=find(cellfun(@(x)strcmp(x,R),table))-1;
            stringnum=stringnum+1;     tablenum=tablenum+1;
            table{
    
    tablenum}=RS;        R=S;
        end
    end
    lzwstring(stringnum)=find(cellfun(@(x)strcmp(x,R),table))-1;
    disp('LZW码串： ')
    disp(lzwstring)
end

python：

import numpy as np

Image = np.array([[30, 30, 30, 30],
                  [110, 110, 110, 110],
                  [30, 30, 30, 30],
                  [110, 110, 110, 110]])

[h, w] = Image.shape
pixelnum = h * w
graynum = 256

if Image.ndim == 2:
    graystring = Image.T.flatten()
    table = {
    
    str(i): i for i in range(graynum)}
    lzwstring = [graynum]
    R = ''
    stringnum = 1

    for i in range(len(graystring)):
        S = str(graystring[i])
        RS = R + S
        if RS in table:
            R = RS
        else:
            lzwstring.append(table[R])
            stringnum += 1
            tablenum = len(table)
            table[RS] = tablenum
            R = S

    lzwstring.append(table[R])
    print('LZW码串：')
    print(lzwstring)