‫‪Chapter 6‬‬

‫‪Image Compression‬‬
‫ﻓﺸﺮدهﺳﺎزي ﺗﺼﻮﻳﺮ‬

‫ﭘﻴﺶ ﻧﻤﺎﻳﺶ)‪(preview‬‬

‫در ﻓﺸﺮدهﺳﺎزي ﺗﺼﻮﻳﺮ ﻣﻘﺪار دادهﻫﺎي ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ﻧﻤﺎﻳﺶ ﺗﺼﻮﻳﺮ دﻳﺠﻴﺘﺎﻟﻲ ﻛﺎﻫﺶ ﻣﻲﻳﺎﺑﺪ‪ .‬ﺑﺮاي اﻧﺠﺎم اﻳﻦ ﻛﺎر ﻳﻚ ﻳﺎ ﭼﻨﺪ ﻋﺎﻣﻞ از‬

‫دادهﻫﺎي اﺿﺎﻓﻲ ﺣﺬف ﻣﻲﺷﻮﻧﺪ‪:‬‬

‫)‪ (1‬اﻓﺰوﻧﮕﻲ ﻛﺪﻫﺎ)‪ (Coding redundancy‬زﻣﺎﻧﻲ اﺳﺘﻔﺎده ﻣﻲﺷﻮد ﻛﻪ از ﺣﺪاﻗﻞ ﻛﺪﻫﺎي ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ﻃﻮل ﺗﺼﻮﻳﺮ ﺑﻬﺮهﺑﺮداري ﺷﻮد‪.‬‬

‫)‪ (2‬اﻓﺰوﻧﮕﻲ ﺑﻴﻦ ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي)‪ :(Interpixel redundancy‬ﻛﻪ ﻧﺘﻴﺠﻪ راﺑﻄﻪ ﻣﺘﻘﺎﺑﻞ ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي اﺳﺖ‬

‫)‪ (3‬اﻓﺰوﻧﮕﻲ رواﻧﻲ – ﺗﺠﺴﻤﻲ)‪ :(Psychovisual redundancy‬ﻛﻪ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ دادهﻫﺎﻳﻲ ﻛﻪ در ﭼﺸﻢ اﻧﺴﺎن ﺑﻪ ﺣﺴﺎب ﻧﻤﻲآﻳﻨﺪ اﻧﺠﺎم‬

‫ﻣﻲﺷﻮد )ﻳﻌﻨﻲ اﻃﻼﻋﺎﺗﻲ ﻛﻪ از ﻧﻈﺮ دﻳﺪاري ﺿﺮوري ﻧﻴﺴﺖ(‪ .‬در اﻳﻦ ﻓﺼﻞ ﻫﺮ ﻳﻚ از اﻳﻦ اﻓﺰوﻧﮕﻲﻫﺎ را ﺑﺮرﺳﻲ ﻛﺮده و ﺷﮕﺮدﻫﺎي ﺑﻬﺮهﺑﺮداري از‬

‫آﻧﻬﺎ را ﺷﺮح ﻣﻲدﻫﻴﻢ و ‪ 2‬اﺳﺘﺎﻧﺪارد ﻓﺸﺮدهﺳﺎزي ﺑﺎ ﭘﺴﻮﻧﺪ ‪ jpeg, jpeg2000‬را ﺷﺮح ﻣﻲدﻫﻴﻢ‪ .‬ﻣﻔﺎﻫﻴﻢ اراﺋﻪ ﺷﺪه در اﻳﻨﺠﺎ در اﻳﻦ‬

‫اﺳﺘﺎﻧﺪاردﻫﺎ ﻳﻜﻲ ﻣﻲﺷﻮﻧﺪ و اﻳﻦ ﺷﮕﺮدﻫﺎ ﺑﺎ دادهﻫﺎي ‪ 3‬ﻧﻮع اﻓﺰوﻧﮕﻲ ﻓﻮق ﻛﺎر ﻣﻲﻛﻨﻨﺪ‪.‬‬

‫از آﻧﺠﺎﺋﻲ ﻛﻪ ﺟﻌﺒﻪ اﺑﺰار ﭘﺮدازش ﺗﺼﻮﻳﺮ ﺗﺎﺑﻌﻬﺎﻳﻲ ﺑﺮاي ﻓﺸﺮدهﺳﺎزي ﺗﺼﻮﻳﺮ ﻧﺪارد‪ ،‬ﻧﻜﺘﻪ اﺻﻠﻲ در اﻳﻦ ﻓﺼﻞ روﺷﻬﺎي ﻛﺎرﺑﺮدي ﺷﮕﺮدﻫﺎي‬

‫ﻓﺸﺮدهﺳﺎزي در ﻧﺮم اﻓﺰار ‪MATLAB‬اﺳﺖ‪ .‬ﻣﺜﻼً ﻳﻚ ﺗﺎﺑﻊ‪ C‬ﻓﺮاﺧﻮانﭘﺬﻳﺮ اﻳﺠﺎد ﻣﻲﻛﻨﻴﻢ ﻛﻪ ﻧﺤﻮه ﻣﺪﻳﺮﻳﺖ دادهﻫﺎﻳﻲ ﺑﺎ ﻃﻮل ﻣﺘﻐﻴﺮ را در‬

‫ﺳﻄﺢ ﺑﻴﺖ ﻧﺸﺎن ﻣﻲدﻫﺪ‪ .‬اﻫﻤﻴﺖ اﻳﻦ ﻧﻜﺘﻪ از آن ﺟﻬﺖ اﺳﺖ ﻛﻪ رﻣﺰﮔﺬاري ﻃﻮل ﻣﺘﻐﻴﺮ ﻧﻜﺘﻪ اﺻﻠﻲ ﻓﺸﺮدهﺳﺎزي ﺗﺼﻮﻳﺮ اﺳﺖ وﻟﻲ ﻧﺮم‬

‫اﻓﺰار‪ MATLAB‬ﺑﺮاي ﭘﺮدازش ﻣﺎﺗﺮﻳﺴﻬﺎﻳﻲ ﺣﺎوي دادهﻫﺎﻳﻲ ﺑﺎ ﻃﻮل ﺛﺎﺑﺖ ﻣﻄﻠﻮب اﺳﺖ‪ .‬ﺣﻴﻦ اﺑﺪاع اﻳﻦ ﺗﺎﺑﻊ ﻓﺮض ﺷﺪه اﺳﺖ ﻛﻪ ﺧﻮاﻧﻨﺪﮔﺎن‬

‫از زﺑﺎن ‪ C‬اﻃﻼع دارﻧﺪ و ﻧﻜﺘﻪ اﺻﻠﻲ اﻳﻦ ﻣﺒﺤﺚ ﻛﻨﺶ و واﻛﻨﺶ ﻧﺮم اﻓﺰار ‪ MATLAB‬ﺑﺎ ﺑﺮﻧﺎﻣﻪﻫﺎي ‪ C‬و ‪ Fortran‬اﺳﺖ ﻛﻪ ﺧﺎرج از اﻳﻦ‬

‫ﻧﺮم اﻓﺰار اﺟﺮا ﻣﻲﺷﻮﻧﺪ‪ .‬اﻫﻤﻴﺖ اﻳﻦ ﻧﻜﺘﻪ در زﻣﺎﻧﻲ اﺳﺖ ﻛﻪ ﺑﺨﻮاﻫﻴﻢ از ﺗﺎﺑﻊﻫﺎي ‪ M‬در ﺑﺮﻧﺎﻣﻪﻫﺎي ‪ Fortran‬و ‪ C‬اﺳﺘﻔﺎده ﻛﻨﻴﻢ و ﻧﻴﺎز ﺑﻪ‬

‫اﻓﺰاﻳﺶ ﺷﺘﺎب ﺗﺎﺑﻌﻬﺎي ‪ M‬ﺑﺮدارﺑﻨﺪي ﺷﺪه ﺑﺎﺷﺪ‪) .‬ﻣﺜﻼً وﻗﺘﻲ ﻧﺘﻮان ﻳﻚ ﺣﻠﻘﻪ ‪ for‬را ﺑﻪ ﻗﺪر ﻛﺎﻓﻲ ﺑﺮدارﺑﻨﺪي ﻛﺮد(‪ .‬ﺗﺎﺑﻌﻬﺎي اﺑﺪاع ﺷﺪه در‬

‫اﻳﻦ ﻓﺼﻞ و ﺗﻮاﻧﺎﻳﻲ ﻧﺮم اﻓﺰار ‪ MATLAB‬ﺑﺮاي ﻛﺎر ﺑﺎ ﺑﺮﻧﺎﻣﻪﻫﺎي ‪ C‬و ‪ Fortran‬ﻃﻮري ﻛﻪ ﺗﺎﺑﻌﻬﺎي ﻓﻮق ﺑﻪ ﺻﻮرت ﻣﺘﻌﺎرف و ﺗﻌﺒﻴﻪ ﺷﺪه‬

‫ﺑﻪ ﻛﺎر ﺑﺮده ﺷﻮﻧﺪ ﺣﺎﻛﻲ از آن اﺳﺖ ﻛﻪ ﻧﺮم اﻓﺰار ‪ MATLAB‬اﺑﺰاري ﻛﺎرآﻣﺪ ﺑﺮاي اﻳﺠﺎد ﻧﻤﻮﻧﻪﻫﺎي اﺻﻠﻲ اﻟﮕﻮرﻳﺘﻤﻬﺎ و ﺳﻴﺴﺘﻢﻫﺎي‬

‫ﻓﺸﺮدهﺳﺎزي اﺳﺖ‪.‬‬

‫‪1‬‬
 ‫‪ .6.1‬ﺗﺎرﻳﺨﭽﻪ)‪(Background‬‬
‫ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﺗﺼﻮﻳﺮ ‪ 6.1‬دﻳﺪه ﻣﻲﺷﻮد‪ ،‬ﺳﻴﺴﺘﻢﻫﺎي ﻓﺸﺮدهﺳﺎزي ﺗﺼﻮﻳﺮ از ‪ 2‬ﺑﻠﻮك ﻣﺘﻤﺎﻳﺰ رﻣﺰﮔﺬار)‪ (Encoder‬و رﻣﺰﮔﺸﺎ)‪(Decoder‬‬

‫ﺗﺸﻜﻴﻞ ﺷﺪهاﻧﺪ‪ .‬ﺗﺼﻮﻳﺮ )‪ f(x, y‬ﺑﻪ رﻣﺰﮔﺬار ﺧﻮراﻧﺪه ﻣﻲﺷﻮد و ﻣﺠﻤﻮﻋﻪاي از ﻧﻤﺎدﻫﺎ از دادهﻫﺎي ورودي اﻳﺠﺎد ﻣﻲﺷﻮد ﻛﻪ از آﻧﻬﺎ ﺑﺮاي ﻧﻤﺎﻳﺶ‬

‫ﺗﺼﻮﻳﺮ اﺳﺘﻔﺎده ﻣﻲﺷﻮد‪ .‬اﮔﺮ ‪ n1, n2‬ﺑﻪ ﺗﺮﺗﻴﺐ ﺗﻌﺪاد واﺣﺪﻫﺎي ﺣﺎﻣﻞ اﻃﻼﻋﺎت )ﺑﺮ ﺣﺴﺐ ﺑﻴﺖ( در ﺗﺼﻮﻳﺮﻫﺎي اﺻﻠﻲ و رﻣﺰﮔﺬاري ﺷﺪه ﺑﺎﺷﻨﺪ‪،‬‬

‫ﻓﺸﺮدهﺳﺎزي را ﻣﻲﺗﻮان از ﻃﺮﻳﻖ ارﻗﺎم ﺑﺎ ﻧﺴﺒﺖ ﻓﺸﺮدهﺳﺎزي ﺳﻨﺠﻴﺪ‪.‬‬

‫‪n1‬‬
‫= ‪CR‬‬
‫‪n2‬‬

‫ﺗﺼﻮﻳﺮ ‪ :6.1‬ﻧﻤﻮداري از ﺳﻴﺴﺘﻢ ﻓﺸﺮدهﺳﺎزي ﺗﺼﻮﻳﺮ‬

‫وﻗﺘﻲ ﻧﺴﺒﺖ ﻓﺸﺮدهﺳﺎزي )‪ (10:1‬ﺑﺎﺷﺪ‪ ،‬ﻳﻌﻨﻲ ﺗﺼﻮﻳﺮ اﺻﻠﻲ در ﻫﺮ واﺣﺪ در دادهﻫﺎي ﻓﺸﺮده ﺷﺪه ‪ 10‬واﺣﺪ ﺣﺎﻣﻞ اﻃﻼﻋﺎت دارد‪ .‬در ﻧﺮم اﻓﺰار‬

‫‪ MATLAB‬ﻧﺴﺒﺖ ﺗﻌﺪاد ﺑﻴﺘﻬﺎي ﻣﻮرد اﺳﺘﻔﺎده ﺑﺮاي ﻧﻤﺎﻳﺶ ‪ 2‬ﭘﺮوﻧﺪه ﺗﺼﻮﻳﺮي و ﻣﺘﻐﻴﺮﻫﺎي ﻣﺮﺑﻮﻃﻪ ﺑﺎ ﺗﺎﺑﻌﻬﺎي ‪ M‬زﻳﺮ ﻣﺤﺎﺳﺒﻪ ﻣﻲﺷﻮد‪.‬‬
‫)‪function cr = imratio(f1, f2‬‬
‫‪%IMRATIO Computes the ratio of the bytes in two images/variables.‬‬
‫‪%‬‬ ‫‪CR = IMRATIO(F1, F2) returns the ratio of the number of bytes in‬‬
‫‪%‬‬ ‫‪variables/ files F1 and F2. If F1 and F2 are an original and‬‬
‫‪%‬‬ ‫‪compressed image, respectively, CR is the compression ratio.‬‬

‫;))‪error(nargchk(2, 2, nargin‬‬ ‫‪% Check input arguments‬‬

‫;)‪cr = bytes(f1) / bytes(f2‬‬ ‫‪% Compute the ratio‬‬

‫‪%-------------------------------------------------------------------------------%‬‬
‫)‪function b = bytes(f‬‬
‫‪% Return the number of bytes in input f. If f is a string, assume‬‬
‫‪% that it is an image filename; if not, it is an image variable.‬‬
‫)‪if ischar(f‬‬

‫‪2‬‬
 ‫;)‪info = dir(f‬‬ ‫;‪b = info.bytes‬‬
‫)‪elseif isstruct(f‬‬
‫‪% MATLAB's whos function reports an extra 124 bytes of memory‬‬
‫‪% per structure field because of the way MATLAB stores‬‬
‫‪% structures in memory. Don’t count this extra memory; instead,‬‬
‫‪% add up the memory associated with each field.‬‬
‫;‪b = 0‬‬
‫;)‪fields = fieldnames(f‬‬
‫)‪for k = 1:length(fields‬‬
‫;))}‪b = b + bytes(f.(fields{k‬‬
‫‪end‬‬
‫‪else‬‬
‫;)'‪info = whos('f‬‬ ‫;‪b = info.bytes‬‬
‫‪end‬‬

‫ﻣﺜﻼً ﻓﺸﺮدهﺳﺎزي ﺗﺼﻮﻳﺮي ﻛﻪ ﺑﺎ ﻣﺤﺘﻮاي ‪ jpeg‬رﻣﺰﮔﺬاري ﺷﺪه اﺳﺖ در ﻋﻜﺲ ‪.2.4‬ﺳﻲ ﻓﺼﻞ ‪ 2‬از ﻃﺮﻳﻖ ﻓﺮﻣﻮﻟﻬﺎي زﻳﺮ ﻗﺎﺑﻞ ﻣﺤﺎﺳﺒﻪ اﺳﺖ‪:‬‬
‫)'‪>> r = imratio(imread('bubbles25.jpg'), 'bubbles25.jpg‬‬
‫= ‪r‬‬
‫‪35.1612‬‬

‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ‪ imratio‬ﺗﺎﺑﻊ داﺧﻠﻲ )‪ b=bytes(f‬اﺳﺖ ﻛﻪ ﺑﺮاي ﺗﻮﻟﻴﺪ ﺗﻌﺪاد ﺑﺎﻳﺘﻬﺎ در ﺳﻪ ﻣﻮرد زﻳﺮ ﺑﻪ ﻛﺎر ﻣﻲرود‪:‬‬

‫)‪ (3‬ﻣﺘﻐﻴﺮ ﻏﻴﺮﺳﺎﺧﺘﺎري ‪.a nonstructure variable‬‬ ‫‪a structure variable‬‬ ‫)‪ (1‬ﭘﺮوﻧﺪه ‪ (2) a file‬ﻣﺘﻐﻴﺮﻫﺎي ﺳﺎﺧﺘﺎري‬

‫اﮔﺮ ‪ f‬ﻣﺘﻐﻴﺮ ﻏﻴﺮﺳﺎﺧﺘﺎري ﺑﺎﺷﺪ‪ ،‬ﺗﺎﺑﻊ ‪ whos‬ﻛﻪ ﺑﺮاي ﺳﻨﺠﺶ اﻧﺪازه آن ﺑﺮ ﺣﺴﺐ ﺑﺎﻳﺖ ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮد‪ .‬اﮔﺮ ‪ f‬اﺳﻢ ﻳﻚ ﭘﺮوﻧﺪه ﺑﺎﺷﺪ‪ ،‬ﺗﺎﺑﻊ‬

‫‪ dir‬ﻛﺎر ﻣﺸﺎﺑﻬﻲ اﻧﺠﺎم ﻣﻲدﻫﺪ‪ .‬در ﺗﺮﻛﻴﺐ اﺳﺘﻔﺎده ﺷﺪه ‪ dir‬ﻳﻚ ﺳﺎﺧﺘﺎر ﺗﻮﻟﻴﺪ ﻣﻲﻛﻨﺪ ﻛﻪ ‪ field’s name, date, bytes, isdir‬در آن‬

‫ﻣﺸﺨﺺ ﺷﺪه اﺳﺖ‪ .‬آﻧﻬﺎ ﺑﻪ ﺗﺮﺗﻴﺐ ﻧﺎم ﭘﺮوﻧﺪه‪ ،‬ﺗﺎرﻳﺦ اﺟﺮاي ﺗﻐﻴﻴﺮات‪ ،‬اﻧﺪازه آن ﺑﺮ ﺣﺴﺐ ﺑﺎﻳﺖ‪ ،‬و ﻣﺴﻴﺮ ﺑﻮدن آن را ﻣﺸﺨﺺ ﻣﻲﻛﻨﻨﺪ )اﮔﺮ‬

‫‪ 1، isdir‬ﺑﺎﺷﺪ ﻣﺴﻴﺮ اﺳﺖ و اﮔﺮ ‪ 0‬ﺑﺎﺷﺪ ﻣﺴﻴﺮ ﻧﻴﺴﺖ( اﮔﺮ ‪ f‬ﻳﻚ ﺳﺎﺧﺘﺎر ﺑﺎﺷﺪ‪ bytes ،‬ﻣﻜﺮراٌ ﺧﻮد را ﻓﺮاﻣﻲﺧﻮاﻧﺪ ﺗﺎ ﺗﻌﺪاد ﺑﺎﻳﺘﻬﺎي ﺗﺨﺼﻴﺺ‬

‫داده ﺷﺪه ﺑﻪ ﻫﺮ ﻣﻴﺪان ﺳﺎﺧﺘﺎر ﺟﻤﻊ ﺑﺴﺘﻪ ﺷﻮد‪ .‬ﺑﻨﺎ ﺑﺮ اﻳﻦ ﺑﺎﻻﺳﺮي ﻣﺘﻐﻴﺮ ﺳﺎﺧﺘﺎري )‪ 124‬ﺑﻴﺖ در ﻫﺮ ﻣﻴﺪان( ﺣﺬف ﻣﻲﺷﻮد و ﻓﻘﻂ ﺗﻌﺪاد‬

‫ﺑﺎﻳﺘﻬﺎي ﻣﻮرد ﻧﻴﺎز ﺑﺮاي دادهﻫﺎي ﻣﻴﺪان ﺗﻮﻟﻴﺪ ﻣﻲﺷﻮد‪ .‬ﺗﺎﺑﻊ ‪ fieldname‬ﺑﺮاي ﺑﻪ دﺳﺖ آوردن ﻓﻬﺮﺳﺖ ﻣﻴﺪاﻧﻬﺎ در ‪ f‬اﺳﺖ و ﻋﺒﺎرﺗﻬﺎي زﻳﺮ‬
‫)‪for k = 1:length(fields‬‬
‫;))}‪b = b + bytes(f.(fields{k‬‬

‫ﺑﺮاي اﺟﺮاي ﺗﻜﺮارﻫﺎ ﻫﺴﺘﻨﺪ‪ .‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ﻛﻪ در ﻓﺮاﺧﻮاﻧﻲ ﻣﻜﺮر ﺑﺎﻳﺘﻬﺎ از اﺳﺎﻣﻲ ﻣﻴﺪاﻧﻬﺎ ﺑﺎ ﺳﺎﺧﺘﺎر ﭘﻮﻳﺎ اﺳﺘﻔﺎده ﺷﺪه اﺳﺖ‪ .‬اﮔﺮ ‪ s‬ﺳﺎﺧﺘﺎر و ‪f‬‬

‫ﻳﻚ ﻣﺘﻐﻴﺮ رﺷﺘﻪاي ﺣﺎوي ﻧﺎم ﻣﻴﺪان ﺑﺎﺷﺪ در ﻋﺒﺎرﺗﻬﺎي زﻳﺮ‬

‫;‪S.(F) = foo‬‬
‫;)‪Field = S.(F‬‬

‫ﺑﺮاي ﺗﻌﻴﻴﻦ ﻳﺎ اﺧﺬ ﻣﺤﺘﻮﻳﺎت ﺳﺎﺧﺘﺎر ‪ f‬از ﺗﺮﻛﻴﺐ ﻧﺎم ﻣﻴﺪان و ﺳﺎﺧﺘﺎر ﭘﻮﻳﺎ اﺳﺘﻔﺎده ﻣﻲﺷﻮد‪.‬‬

‫ﺑﺮاي ﻧﻤﺎﻳﺶ ﻳﺎ اﺳﺘﻔﺎده از ﻳﻚ ﺗﺼﻮﻳﺮ رﻣﺰﮔﺬاري ﺷﺪه ﻓﺸﺮده اﺑﺘﺪا ﺑﺎﻳﺪ آن را ﺑﻪ رﻣﺰﮔﺸﺎ )ﺗﺼﻮﻳﺮ ‪ (6.1‬داد ﺗﺎ ﺗﺼﻮﻳﺮ ﺧﺮوﺟﻲ )‪ f(x, y‬ﺑﺎزﺳﺎزي‬

‫ﺷﻮد‪ .‬ﻣﻤﻜﻦ اﺳﺖ )‪ f’(x, y‬ﻧﻤﺎد دﻗﻴﻘﻲ از )‪ f(x, y‬ﺑﺎﺷﺪ ﻳﺎ ﻧﺒﺎﺷﺪ‪ .‬اﮔﺮ ﺑﺎﺷﺪ ﺳﻴﺴﺘﻢ را ﻋﺎري ازﺧﻄﺎ)‪،(error free‬ﻣﺤﺎﻓﻆ اﻃﻼﻋﺎت‬
‫‪3‬‬
‫ در ﺣﺎﻟﺖ‬.‫ اﮔﺮ ﻧﺒﺎﺷﺪ ﻳﻌﻨﻲ ﺗﺼﻮﻳﺮ ﺑﺎزﺳﺎزي ﺷﺪه ﺗﺤﺮﻳﻒ ﺷﺪه اﺳﺖ‬.‫( ﻣﻲﻧﺎﻣﻴﻢ‬lossless)‫( ﻳﺎ ﺑﺪون ﺧﺴﺎرت‬information preserving)

‫ ﺑﺮاي ﻫﺮ‬f’(x, y) ‫ و‬f(x, y) ‫ را ﺑﻴﻦ‬e(x, y) ‫ ﻣﻲﺗﻮان ﺧﻄﺎي‬،‫( ﻣﻲﻧﺎﻣﻴﻢ‬lossy compression) ‫دوم ﻛﻪ آن را ﻓﺸﺮدهﺳﺎزي اﺗﻼف ﺷﺪه‬

.‫ ﺗﻌﺮﻳﻒ ﻛﺮد‬y‫ و‬x ‫ﻣﻘﺪار از‬

e( x , y ) = f̂ ( x , y ) − f ( x , y )
:‫ﻃﻮري ﻛﻪ ﻣﺠﻤﻮع ﺧﻄﺎﻫﺎي ﺑﻴﻦ دو ﺗﺼﻮﻳﺮ ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ‬

‫ ﮔﺮﻓﺘﻪ ﺷﺪه اﺳﺖ‬m*n ‫ اﺳﺖ ﻛﻪ ﻣﻴﺎﻧﮕﻴﻦ آن در اراﻳﻪ‬2 ‫ رﻳﺸﻪ دوم ﺧﻄﺎ ﺑﻪ ﺗﻮان‬f’(x, y) ‫ و‬f(x, y) ‫و ﺟﺬر ﻣﻴﺎﻧﮕﻴﻦ ﻣﺮﺑﻌﺎت ﺑﻴﻦ‬

?
.

e(x, y) ‫ از آﻧﺠﺎﺋﻲ ﻛﻪ‬.‫ و ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎي آن را ﻧﺸﺎن ﻣﻲدﻫﺪ‬e(x, y) ‫ ﻏﻴﺮ از ﺻﻔﺮ ﺑﺎﺷﺪ‬erms ‫ را ﻣﺤﺎﺳﺒﻪ ﻛﺮده و اﮔﺮ‬erms ‫ زﻳﺮ‬M ‫ﺗﺎﺑﻊ‬

hist ‫ )ﻛﻪ ﻓﻘﻂ ﺑﺎ دادهﻫﺎي ﺗﺼﻮﻳﺮي ﻛﺎر ﻣﻲﻛﻨﺪ( از‬imhist ‫ ﺑﺮاي ﺗﻮﻟﻴﺪ ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎ ﺑﻪ ﺟﺎي‬،‫ﻣﻲﺗﻮاﻧﺪ ﻣﻘﺎدﻳﺮ ﻣﺜﺒﺖ ﻳﺎ ﻣﻨﻔﻲ داﺷﺘﻪ ﺑﺎﺷﺪ‬

.‫اﺳﺘﻔﺎده ﻣﻲﺷﻮد‬
function rmse = compare(f1, f2, scale)
%COMPARE Computes and displays the error between two matrices.
% RMSE = COMPARE(F1, F2, SCALE) returns the root-mean-square error
% between inputs F1 and F2, displays a histogram of the difference,
% and displays a scaled difference image. When SCALE is omitted, a
% scale factor of 1 is used.

% Check input arguments and set defaults.

error(nargchk(2, 3, nargin));
if nargin < 3
scale = 1;
end
% Compute the root-mean-square error
e = double(f1) – double(f2);
[m, n] = size(e);
rmse = sqrt(sum(e(:) .^ 2) / (m * n));

% Output error image & histogram if an error(i.e., rmse ~= 0).

If rmse
% Form error histogram.
Emax = max(abs(e:)));
[h, x] = hist(e(:), emax;
if length(h) >= 1
figure; bar(x, h, 'k');
% Scale the error image symmetrically and display
emax = emax / scale;
e = mat2gray(e, [-emax, emax]);
figure; imshow(e);
end
end

4
‫رﻣﺰﮔﺬار ﺗﺼﻮﻳﺮ ‪ 6.1‬ﻣﺴﺌﻮل ﻛﺎﻫﺶ اﻓﺰوﻧﮕﻲ رﻣﺰﮔﺬاري‪ ،‬ﺑﻴﻦ ﭘﻴﻜﺴﻠﻲ و رواﻧﻲ‪-‬دﻳﺪاري ﺗﺼﻮﻳﺮ ورودي اﺳﺖ‪ .‬ﻧﻘﺸﻪﺑﺮدار در اوﻟﻴﻦ ﻣﺮﺣﻠﻪ ﻓﺮاﻳﻨﺪ‬

‫رﻣﺰﮔﺬاري ﺗﺼﻮﻳﺮ ورودي را ﺑﻪ ﻗﺎﻟﺒﻲ ﻏﻴﺮﺗﺼﻮﻳﺮي ﺗﺒﺪﻳﻞ ﻣﻲﻛﻨﺪ ﻛﻪ ﺑﺮاي ﻛﺎﻫﺶ اﻓﺰوﻧﮕﻲ ﻋﻨﺎﺻﺮ ﺑﻴﻦ ﺗﺼﻮﻳﺮي ﻃﺮاﺣﻲ ﺷﺪه اﺳﺖ‪ .‬در ﻣﺮﺣﻠﻪ‬

‫دوم ﻳﻚ ﺑﻠﻮك ﻣﺒﺪل دﻗﺖ دادهﻫﺎي ﺧﺮوﺟﻲ اﺑﺰار ﻧﻘﺸﻪﺑﺮدار را ﻣﻄﺎﺑﻖ ﺑﺎ ﻣﻌﻴﺎرﻫﺎي وﻓﺎداري از ﭘﻴﺶ ﺗﻌﻴﻴﻦ ﺷﺪه ﻛﺎﻫﺶ ﻣﻲدﻫﺪ ﺗﺎ دادهﻫﺎﻳﻲ‬

‫ﻛﻪ از ﻧﻈﺮ رواﻧﻲ – دﻳﺪاري اﺿﺎﻓﻪ ﻫﺴﺘﻨﺪ ﺣﺬف ﺷﻮﻧﺪ‪ .‬اﻳﻦ ﻋﻤﻠﻴﺎت ﺑﺮﮔﺸﺖﻧﺎﭘﺬﻳﺮ اﺳﺖ و اﮔﺮ ﻓﺸﺮدهﺳﺎزي ﺑﺪون ﺧﻄﺎ ﻣﻮرد ﻧﻈﺮ ﺑﺎﺷﺪ ﺑﺎﻳﺪ‬

‫ﺣﺬف ﺷﻮد‪ .‬در ﻣﺮﺣﻠﻪ ﺳﻮم و ﻧﻬﺎﻳﻲ اﻳﻦ ﻓﺮاﻳﻨﺪ ﻳﻚ رﻣﺰﮔﺬار ﻧﻤﺎدﻳﻦ رﻣﺰي اﻳﺠﺎد ﻣﻲﻛﻨﺪ ﻛﻪ اﻓﺰوﻧﮕﻲ رﻣﺰﮔﺬاري را در ﻣﺒﺪل دادهﻫﺎي ﺧﺮوﺟﻲ‬

‫ﻛﺎﻫﺶ ﻣﻲدﻫﺪ و دادهﻫﺎي ﺧﺮوﺟﻲ را ﻣﻄﺎﺑﻖ ﺑﺎ رﻣﺰ ﻧﻘﺸﻪ ﺑﺮداري ﻣﻲﻛﻨﺪ‪.‬‬

‫رﻣﺰﮔﺸﺎي ﺗﺼﻮﻳﺮ ‪، 6.1‬دو ﻣﻮﻟﻔﻪ دارد‪ :‬رﻣﺰﮔﺸﺎي ﻧﻤﺎدﻳﻦ )‪ (symbol decoder‬و ﻧﻘﺸﻪ ﺑﺮدار ﻣﻌﻜﻮس )‪ .(inverse mapper‬اﻳﻦ ﻗﻄﻌﻪﻫﺎ‬

‫ﻣﻌﻜﻮس اﺟﺮا ﻣﻲﺷﻮﻧﺪ‪ ،‬ﻋﻤﻠﻴﺎت ﻣﻌﻜﻮس رﻣﺰﮔﺬار ﻧﻤﺎدﻳﻦ و ﻧﻘﺸﻪ ﺑﺮدار ﺟﻠﻮي ﻳﻜﺪﻳﮕﺮ را ﻣﻲﮔﻴﺮﻧﺪ زﻳﺮا ﺗﺒﺪﻳﻞ ﺑﺮﮔﺸﺖﻧﺎﭘﺬﻳﺮ اﺳﺖ و ﺑﻠﻮك‬

‫ﺗﺒﺪﻳﻞ ﻣﻌﻜﻮس درج ﻧﻤﻲﺷﻮد‪.‬‬

‫‪ .6.2‬اﻓﺰوﻧﮕﻲ رﻣﺰﮔﺬاري ) ‪(Coding Redundancy‬‬

‫ﻓﺮض ﻛﻨﻴﺪ ﻣﺘﻐﻴﺮ ﺗﺼﺎدﻓﻲ ﻣﺘﻤﺎﻳﺰ ‪ k=1, 2,…l‬ﺑﺎ اﺣﺘﻤﺎﻻت )‪ pr(rk‬ﻧﻤﺎﻳﺎﻧﮕﺮ ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﻳﻚ ﺗﺼﻮﻳﺮ ﺑﺎ ﺳﻄﺢ ال ﺧﺎﻛﺴﺘﺮي‬

‫)‪ (l_gray_level‬ﺑﺎﺷﺪ‪ R1 .‬ﻫﻤﭽﻮن ﻓﺼﻞ ‪ 3‬ﻣﻄﺎﺑﻖ ﺑﺎ ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي ‪ 0‬اﺳﺖ)زﻳﺮا اراﻳﻪﻫﺎي ‪ MATLAB‬ﻧﻤﻲﺗﻮاﻧﻨﺪ ﺻﻔﺮ ﺑﺎﺷﻨﺪ(‬

‫‪nk‬‬
‫= ) ‪pr (rk‬‬ ‫‪k = 1,2,..., L‬‬
‫‪n‬‬
‫در اﻳﻨﺠﺎ ‪ nk‬ﺗﻌﺪاد دﻓﻌﺎﺗﻲ اﺳﺖ ﻛﻪ ‪ k‬اﻣﻴﻦ ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي در ﺗﺼﻮﻳﺮ ﻇﺎﻫﺮ ﻣﻲﺷﻮد و ‪ n‬ﺗﻌﺪاد ﻛﻞ ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي ﻣﻮﺟﻮد در ﻋﻜﺲ اﺳﺖ‪.‬‬

‫اﮔﺮ ﺗﻌﺪاد ﺑﻴﺘﻬﺎي ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ﻧﻤﺎﻳﺶ ﻣﻘﺪار ‪ rk‬ﻣﻌﺎدل )‪ l(rk‬ﺑﺎﺷﺪ ﻣﻴﺎﻧﮕﻴﻦ ﺑﻴﺘﻬﺎي ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ﻧﻤﺎﻳﺶ ﻫﺮ ﻋﻨﺼﺮ ﺗﺼﻮﻳﺮي ﺑﻪ ﺷﺮح زﻳﺮ‬

‫اﺳﺖ‪:‬‬
‫‪L‬‬
‫) ‪Lavg = ∑ l (rk ) pr (rk‬‬
‫‪k =1‬‬

‫ﻳﻌﻨﻲ ﻣﻴﺎﻧﮕﻴﻦ ﻃﻮل ﻛﻠﻤﺎت رﻣﺰي ﺗﺨﺼﻴﺺ داده ﺷﺪه ﻣﻘﺎدﻳﺮ ﮔﻮﻧﺎﮔﻮن ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي ﺑﺎ ﺟﻤﻊ ﻣﺠﻤﻮع ﺗﻌﺪاد ﺑﻴﺘﻬﺎي ﻣﻮرد اﺳﺘﻔﺎده ﺑﺮاي‬

‫ﻧﻤﺎﻳﺶ ﻫﺮ ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي و اﺣﺘﻤﺎل وﻗﻮع ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي ﻣﺸﺨﺺ ﻣﻲﺷﻮد‪ .‬ﺑﻨﺎ ﺑﺮ اﻳﻦ ﻛﻞ ﺗﻌﺪاد ﺑﻴﺘﻬﺎي ﻣﻮرد ﻧﻴﺎز ﺑﺮاي رﻣﺰﮔﺬاري‬

‫ﺗﺼﻮﻳﺮ‪M*N‬ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ ‪.MNLavg‬‬

‫وﻗﺘﻲ ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﻳﻚ ﺗﺼﻮﻳﺮ ﺑﺎ اﺳﺘﻔﺎده از رﻣﺰ دودوﻳﻲ ‪ m‬ﺑﻴﺖ ﻃﺒﻴﻌﻲ ﻧﻤﺎﻳﺶ داده ﻣﻲﺷﻮﻧﺪ‪ ،‬ﺳﻤﻦ راﺳﺖ ﻣﻌﺎدﻟﻪ ﻗﺒﻞ ﺑﻪ ‪ m‬ﺑﻴﺖ‬

‫ﻛﺎﻫﺶ ﻣﻲﻳﺎﺑﺪ‪.‬‬

‫‪5‬‬
 ‫ﺟﺪول ‪ :6.1‬ﻳﻚ ﻣﺜﺎل از اﻓﺰوﻧﮕﻲ رﻣﺰﮔﺬاري‬

‫ﻳﻌﻨﻲ وﻗﺘﻲ ‪ m‬ﺟﺎﻳﮕﺰﻳﻦ )‪ l(rk‬ﺷﻮد ‪ lavg=m‬ﻣﻲﺷﻮد‪ .‬ﺳﭙﺲ ‪ m‬ﺛﺎﺑﺖ ﺧﺎرج از ﻣﺠﻤﻮع ﺑﺮده ﻣﻲﺷﻮد و ﻓﻘﻂ ﻣﺠﻤﻮع )‪ pr(rk‬ﺑﺮاي ‪1<k<l‬‬

‫ﺑﺎﻗﻲ ﻣﻲﻣﺎﻧﺪ‪ .‬ﻛﻪ ﻣﺴﺎوي ‪ 1‬اﺳﺖ‪ .‬ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﺟﺪول ‪ 6.1‬دﻳﺪه ﻣﻲﺷﻮد‪ ،‬وﻗﺘﻲ ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﻳﻚ ﺗﺼﻮﻳﺮ ﺑﺎ اﺳﺘﻔﺎده از ﻛﺪ دودوﻳﻲ‬

‫ﻃﺒﻴﻌﻲ رﻣﺰﮔﺬاري ﻣﻲﺷﻮﻧﺪ اﻓﺰوﻧﮕﻲ رﻣﺰﮔﺬاري ﻫﻤﻴﺸﻪ وﺟﻮد دارد‪ .‬در اﻳﻦ ﺟﺪول رﻣﺰﮔﺬاري ﻃﻮل ﺛﺎﺑﺖ و ﻣﺘﻐﻴﺮ ﺗﺼﻮﻳﺮ ‪ 4‬ﺳﻄﺤﻲ دﻳﺪه‬

‫ﻣﻲﺷﻮد ﻛﻪ ﺗﻮزﻳﻊ ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي آن در ﺳﺘﻮن ‪ 2‬ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‪ .‬ﻣﻴﺎﻧﮕﻴﻦ ﻃﻮل رﻣﺰﮔﺬاري دودوﻳﻲ ‪ 2‬ﺑﻴﺘﻲ در ﺳﺘﻮن ‪ 3‬دو ﺑﻴﺖ‬

‫اﺳﺖ‪ .‬ﻣﻴﺎﻧﮕﻴﻦ ﺗﻌﺪاد ﺑﻴﺘﻬﺎي ﻣﻮرد ﻧﻴﺎز در رﻣﺰﮔﺬاري ‪ 2‬در ﺳﺘﻮن ‪ 5‬ﺑﺎ راﺑﻄﻪ زﻳﺮ ﺣﺎﺻﻞ ﻣﻲﺷﻮد و‬

‫?‬

‫ﻧﺴﺒﺖ ﻓﺸﺮدهﺳﺎزي ﺣﺎﺻﻞ از آن ‪ cr=2/1825=1103‬اﺳﺖ‪ .‬ﻣﺒﻨﺎي ﻓﺸﺮدهﺳﺎزي رﻣﺰ ‪ 2‬آن اﺳﺖ ﻛﻪ ﻛﻠﻤﺎت آن ﻃﻮل ﻣﺘﻐﻴﺮ دارﻧﺪ‪ .‬ﺑﻨﺎ ﺑﺮ اﻳﻦ‬

‫ﻛﻮﺗﺎﻫﺘﺮﻳﻦ ﻛﻠﻤﺎت ﺑﻪ ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﺗﺨﺼﻴﺺ داده ﻣﻲﺷﻮﻧﺪ ﻛﻪ ﺑﻪ ﺗﻌﺪاد دﻓﻌﺎت ﺑﻴﺸﺘﺮي در ﺗﺼﻮﻳﺮ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﻨﺪ‪.‬‬

‫ﺳﻮال آن اﺳﺖ ﻛﻪ ﺑﺮاي ﻧﻤﺎﻳﺶ ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﺗﺼﻮﻳﺮ ﭼﻨﺪ ﺑﻴﺖ واﻗﻌﺎً ﻣﻮرد ﻧﻴﺎز اﺳﺖ؟ ﺣﺪاﻗﻞ ﺗﻌﺪاد داده ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ﻧﻤﺎﻳﺶ ﺗﺼﻮﻳﺮ‬

‫ﺑﺪون از دﺳﺖ دادن اﻃﻼﻋﺎت ﭼﻘﺪر اﺳﺖ؟ ﺑﺮاي ﭘﺎﺳﺦ دادن ﺑﻪ اﻳﻦ ﻣﻮﺿﻮع و ﭘﺮﺳﺸﻬﺎي ﻣﺮﺗﺒﻂ ﺑﻪ ﻓﺮﺿﻴﻪ اﻃﻼﻋﺎت ﻣﺮاﺟﻌﻪ ﻣﻲﻛﻨﻴﻢ‪ .‬اﺻﻞ‬

‫ﺣﺎﻛﻢ ﺑﺮ آن اﻳﻦ اﺳﺖ ﻛﻪ اﻟﮕﻮي ﺗﻮﻟﻴﺪ اﻃﻼﻋﺎت ﺑﺮ اﺳﺎس ﻓﺮاﻳﻨﺪ اﺣﺘﻤﺎﻻت اﺳﺖ و ﺑﻪ ﺷﻜﻠﻲ ﻣﻄﺎﺑﻖ ﺑﺎ ﺣﺲ ﺷﺸﻢ ﺳﻨﺠﻴﺪه ﻣﻲﺷﻮد‪ .‬ﻃﺒﻖ اﻳﻦ‬

‫ﻓﺮﺿﻴﻪ ﺗﻌﺪاد واﺣﺪﻫﺎي اﻃﻼﻋﺎﺗﻲ روﻳﺪاد ﺗﺼﺎدﻓﻲ‪ E‬ﺑﺎ اﺣﺘﻤﺎل )‪ P(E‬ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ‪:‬‬

‫?‬

‫اﮔﺮ ‪ P(E)=1‬ﺑﺎﺷﺪ ﻳﻌﻨﻲ اﻳﻦ روﻳﺪاد ﻫﻤﻮاره اﺗﻔﺎق اﻓﺘﺪ‪ I(E)=0 ،‬ﻣﻲﺷﻮد و ﻫﻴﭻ اﻃﻼﻋﺎﺗﻲ ﺑﻪ آن ﻣﺮﺗﺒﻂ ﻧﻴﺴﺖ‪ .‬از آﻧﺠﺎﺋﻲ ﻛﻪ ﻫﻴﭻ ﻧﻮع‬

‫اﺑﻬﺎﻣﻲ ﺑﺎ اﻳﻦ روﻳﺪاد ارﺗﺒﺎط ﻧﺪارد‪ ،‬وﻗﻮع اﻳﻦ روﻳﺪاد ﺑﺎﻋﺚ اﻧﺘﻘﺎل ﻫﻴﭻ اﻃﻼﻋﺎﺗﻲ ﻧﻤﻲﺷﻮد‪ .‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ اﻳﻦ روﻳﺪادﻫﺎي ﺗﺼﺎدﻓﻲ و ﻣﺠﻤﻮﻋﻪ وﻗﺎﻳﻊ‬

‫‪6‬‬
‫اﺣﺘﻤﺎﻟﻲ ]‪ [a1,a2,…,aj‬ﺑﺎ اﺣﺘﻤﺎﻻت })‪ {p(a1),p(a2),..p(aj‬ﻣﻴﺎﻧﮕﻴﻦ اﻃﻼﻋﺎت ﻣﻨﺒﻊ ﺧﺮوﺟﻲ ﻛﻪ درﺟﻪ ﺑﻲﻧﻈﻤﻲ ﻣﻨﺒﻊ ﻧﺎﻣﻴﺪه ﻣﻲﺷﻮد ﺑﻪ‬

‫ﺷﺮح زﻳﺮ اﺳﺖ‪:‬‬

‫?‬

‫اﮔﺮ ﺗﺼﻮﻳﺮي ﺑﻪ ﻋﻨﻮان ﻧﻤﻮﻧﻪاي از ﻣﻨﺒﻊ ﺧﺎﻛﺴﺘﺮي ﺳﺎﻃﻊ ﻛﻨﻨﺪه آن ﺗﻌﺒﻴﺮ ﺷﻮد‪ ،‬ﻣﻲﺗﻮان ﺑﺮاي اﻟﮕﻮﺑﺮداري اﺣﺘﻤﺎﻻت ﻧﻤﺎد آن ﻣﻨﺒﻊ از ﭘﻴﺸﻴﻨﻪ‬

‫ﻧﻤﺎي)‪ (histogram‬ﺧﺎﻛﺴﺘﺮي ﺗﺼﻮﻳﺮ ﻣﺸﺎﻫﺪه ﺷﺪه اﺳﺘﻔﺎده ﻛﺮد و ﺑﺮآورد درﺟﻪ ﻳﻚ درﺟﻪ ﺑﻲﻧﻈﻤﻲ ﻣﻨﺒﻊ را ﺗﺨﻤﻴﻦ زد‪.‬‬

‫?‬

‫)‪function h = entropy(x, n‬‬

‫‪%ENTROPY Computes a first-order estimate of the entropy of a matrix.‬‬
‫‪%‬‬ ‫‪H = ENTROPY(X, N) returns the first-order estimate of matrix X‬‬
‫‪%‬‬ ‫‪with N symbols (N = 256 if omitted) in bits/symbol. The estimate‬‬
‫‪%‬‬ ‫‪assumes a statistically independent source characterized by the‬‬
‫‪%‬‬ ‫‪relative frequency of occurrence of the elements in X.‬‬

‫;))‪error(nargchk(1, 2, nargin‬‬ ‫‪% Check input arguments‬‬

‫‪if nargin < 2‬‬
‫;‪n = 256‬‬ ‫‪% Default for n.‬‬
‫‪end‬‬

‫;)‪x = double(x‬‬ ‫‪% Make input double‬‬

‫;)‪xh = hist(x(:), n‬‬ ‫‪% Compute N-bin histogram‬‬
‫;))‪xh = xh / sum(xh(:‬‬ ‫‪% Compute probabilities‬‬
‫‪% Make mask to eliminate 0's since log2(0) = -inf.‬‬
‫;)‪i = find(xh‬‬

‫;)))‪h = -sum(xh(i). *log2(xh(i‬‬ ‫‪% Compute entropy‬‬

‫ﺑﻪ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ ‪ find‬در ﻧﺮم اﻓﺰار ‪ MATLAB‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ‪ ،‬ﻛﻪ ﺑﺮاي ﻧﻤﺎﻳﺶ ﺷﺎﺧﺼﻬﺎي ﻋﻨﺎﺻﺮ ﻏﻴﺮﺻﻔﺮ ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎي ‪ xh‬ﺑﻪ ﻛﺎر ﺑﺮده‬

‫ﺷﺪه اﺳﺖ‪ .‬ﻋﺒﺎرت )‪ find (x‬ﻣﻌﺎدل ﻋﺒﺎرت )‪ find (x~=0‬اﺳﺖ‪ .‬ﺗﺎﺑﻊ درﺟﻪ ﺑﻲﻧﻈﻤﻲ ﺑﺮاي اﻳﺠﺎد ﺑﺮدار ﺷﺎﺧﺼﻬﺎي ‪ I‬در ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎي ‪ xh‬از‬

‫‪ find‬اﺳﺘﻔﺎده ﻣﻲﻛﻨﺪ ﻛﻪ ﺑﺮاي ﺣﺬف ﻛﻠﻴﻪ ﻋﻨﺎﺻﺮ ﺑﺎ ﻣﻘﺪار ﺻﻔﺮ از ﻣﺤﺎﺳﺒﻪ درﺟﻪ ﺑﻲﻧﻈﻤﻲ در ﻋﺒﺎرت ﻧﻬﺎﻳﻲ ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮﻧﺪ‪ .‬اﮔﺮ اﻳﻦ ﻛﺎر‬

‫اﻧﺠﺎم ﻧﺸﻮد‪ ،‬ﺗﺎﺑﻊ ‪ log2‬دادهﻫﺎي ﺧﺮوﺟﻲ ‪ h‬را ﺑﻪ زور ﺑﻪ ‪ Nan‬ﻣﻲدﻫﺪ )‪ 0*-inf‬ﻳﻚ ﻋﺪد ﻧﻴﺴﺖ(در ﺣﺎﻟﺘﻲ ﻛﻪ ﻧﻤﺎد اﺣﺘﻤﺎﻻت ﺻﻔﺮ ﺑﺎﺷﺪ‪.‬‬

‫ﻣﺜﺎل ‪ :6.1‬ﻣﺤﺎﺳﺒﻪ ﺑﺮآورد ﺷﺎﺧﺺ درﺟﻪ ﺑﻲﻧﻈﻤﻲ‪:‬‬

‫ﻳﻚ ﺗﺼﻮﻳﺮ ﺳﺎده ‪ 4*4‬را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ ﻛﻪ ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎي آن ) ‪ p‬در ﻛﺪ ﺑﻌﺪي( اﺣﺘﻤﺎﻻت ﻧﻤﺎد را در ﺟﺪول ‪ 6.1‬اﻟﮕﻮﺑﺮداري ﻛﻨﺪ‪ .‬ﺗﺮﺗﻴﺐ‬

‫ﻋﺒﺎرﺗﻬﺎ در ﺧﻂ ﻓﺮﻣﺎن زﻳﺮ ﭼﻨﻴﻦ ﺗﺼﻮﻳﺮي را اﻳﺠﺎد ﻣﻲﻛﻨﺪ و ﺷﺎﺧﺺ درﺟﻪ ﺑﻲﻧﻈﻤﻲ آن را ﻣﺤﺎﺳﺒﻪ و ارزﻳﺎﺑﻲ ﻣﻲﻛﻨﺪ‪.‬‬

‫‪7‬‬
‫;]‪>> f = [119 123 168 119; 123 119 168 168‬‬
‫];‪>> f = [f; 119 119 107 119; 107 107 119 119‬‬
‫= ‪f‬‬
‫‪119‬‬ ‫‪123‬‬ ‫‪168‬‬ ‫‪119‬‬
‫‪123‬‬ ‫‪119‬‬ ‫‪168‬‬ ‫‪168‬‬
‫‪119‬‬ ‫‪119‬‬ ‫‪107‬‬ ‫‪119‬‬
‫‪107‬‬ ‫‪107‬‬ ‫‪119‬‬ ‫‪119‬‬
‫;)‪p = hist(f(:), 8‬‬
‫)‪p = p / sum(p‬‬
‫= ‪p‬‬
‫‪0.1875 0.5‬‬ ‫‪0.125‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬ ‫‪0.1875‬‬
‫)‪h = entropy(f‬‬
‫= ‪h‬‬
‫‪1.7806‬‬

‫رﻣﺰ ‪ 2‬ﺟﺪول ‪ 6.1‬ﺑﺎ ‪ lavg=1.81‬ﻧﺰدﻳﻚ ﺑﻪ ﺑﺮآورد ﺷﺎﺧﺺ درﺟﻪ ﺑﻲﻧﻈﻤﻲ اﺳﺖ و ﻛﺪ دودوﻳﻲ ﺣﺪاﻗﻞ ﻃﻮل ﺗﺼﻮﻳﺮ ‪ f‬اﺳﺖ‪ .‬ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ‬

‫ﻛﻪ ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي ‪ 107‬ﻣﻄﺎﺑﻖ ﺑﺎ ‪ r1‬و ﻛﻠﻤﺎت رﻣﺰي دودوﻳﻲ ‪( 011 )2‬ﻣﻄﺎﺑﻖ ﺑﺎ ﺟﺪول ‪ 6.1‬و ‪ 119‬ﻣﻄﺎﺑﻖ ﺑﺎ ‪ r2‬و ﻛﺪﻫﺎي ‪ 123 ،(1)2‬و‬

‫‪ 168‬ﺑﻪ ﺗﺮﺗﻴﺐ ﻣﻄﺎﺑﻖ ﺑﺎ ‪ (010)2‬و ‪ (00)2‬ﻫﺴﺘﻨﺪ‪.‬‬

‫‪ .6.2.1‬رﻣﺰﻫﺎي ﻫﺎﻓﻤﻦ)‪(Huffman codes‬‬

‫ﻫﻨﮕﺎم رﻣﺰﮔﺬاري ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي) ‪ (gray levels‬ﻳﻚ ﺗﺼﻮﻳﺮ و ﻳﺎ دادهﻫﺎي ﺧﺮوﺟﻲ ﻋﻤﻠﻴﺎت ﻧﻘﺸﻪ ﺑﺮداري ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي )اﺧﺘﻼف‬

‫ﭘﻴﻜﺴﻠﻬﺎ‪ ،‬ﻃﻮل و ﻏﻴﺮه( ﻛﺪﻫﺎي ﻫﺎﻓﻤﻦ ﻛﻤﺘﺮﻳﻦ ﺗﻌﺪاد ﻧﻤﺎدﻫﺎي رﻣﺰي )ﻣﺜﻞ ﺑﻴﺖ( را در ﻫﺮ ﻧﻤﺎد ﻣﻨﺒﻊ )ﻣﺜﻼً ﻣﻘﻴﺎس ﺧﺎﻛﺴﺘﺮي( دارﻧﺪ و‬

‫ﻣﺤﺪودﻳﺖ آﻧﻬﺎ آن اﺳﺖ ﻛﻪ ﻧﻤﺎدﻫﺎي ﻣﻨﺒﻊ ﻳﻚ ﺑﻪ ﻳﻚ رﻣﺰﮔﺬاري ﻣﻲﺷﻮﻧﺪ‪.‬‬

‫اوﻟﻴﻦ ﮔﺎم در روش ﻫﺎﻓﻤﻦ اﻳﺠﺎد واﺣﺪﻫﺎي ﻛﺎﻫﺶ ﻣﻨﺒﻊ ﺑﺎ ﻣﺮﺗﺐ ﻛﺮدن اﺣﺘﻤﺎﻻت ﻧﻤﺎدﻫﺎي ﻣﻮرد ﻧﻈﺮ و ادﻏﺎم ﻧﻤﺎدﻫﺎي ﻛﻢ اﺣﺘﻤﺎل ﺑﺎ ﻧﻤﺎدﻫﺎي‬

‫ﺗﻜﻲ اﺳﺖ ﻛﻪ در ﻣﺮﺣﻠﻪ ﻛﺎﻫﺶ ﺑﻌﺪي ﺟﺎﻳﮕﺰﻳﻦ آﻧﻬﺎ ﻣﻲﺷﻮﻧﺪ‪ .‬درﺗﺼﻮﻳﺮ‪( a).6.2‬اﻳﻦ ﻓﺮاﻳﻨﺪ ﺑﺮاي ﺗﻮزﻳﻊ ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي در ﺟﺪول ‪ 6.1‬ﻧﺸﺎن‬

‫داده ﺷﺪه اﺳﺖ‪ .‬در ﺳﻤﺖ ﭼﭗ ﻣﺠﻤﻮﻋﻪ ﻣﻘﺪﻣﺎﺗﻲ ﻧﻤﺎدﻫﺎي ﻣﻨﺒﻊ و اﺣﺘﻤﺎﻻت آﻧﻬﺎ از ﺑﺎﻻ ﺑﻪ ﭘﺎﻳﻴﻦ ﺑﺮ ﺣﺴﺐ ﻣﻘﺎدﻳﺮ اﺣﺘﻤﺎﻻت ﻣﺮﺗﺐ ﺷﺪهاﻧﺪ‪.‬‬

‫ﺑﺮاي ﻛﺎﻫﺶ اوﻟﻴﻦ ﻣﻨﺒﻊ دو اﺣﺘﻤﺎل آﺧﺮ ﻳﻌﻨﻲ ‪ 0.125‬و ‪ 0.1875‬ﺑﺎ ﻫﻢ ادﻏﺎم ﻣﻲﺷﻮﻧﺪ ﺗﺎ ﻳﻚ ﻧﻤﺎد ﺗﺮﻛﻴﺒﻲ ﺑﺎ اﺣﺘﻤﺎل ‪ 0.3125‬اﻳﺠﺎد ﺷﻮد‪.‬‬

‫اﻳﻦ ﻧﻤﺎد ﺗﺮﻛﻴﺒﻲ و اﺣﺘﻤﺎل ﻣﺮﺗﺒﻂ ﺑﺎ آن در اوﻟﻴﻦ ﺳﺘﻮن ﻛﺎﻫﺶ ﻣﻨﺒﻊ ﻗﺮار داده ﻣﻲﺷﻮﻧﺪ ﻃﻮري ﻛﻪ اﺣﺘﻤﺎﻻت ﻣﻨﺒﻊ ﻛﺎﻫﺶ ﻳﺎﻓﺘﻪ از ﺣﺪاﻛﺜﺮ ﺗﺎ‬

‫ﺣﺪاﻗﻞ اﺣﺘﻤﺎﻻت ﻣﺮﺗﺐ ﻣﻲﺷﻮﻧﺪ‪ .‬اﻳﻦ ﻓﺮاﻳﻨﺪ آﻧﻘﺪر ﺗﻜﺮار ﻣﻲﺷﻮد ﺗﺎ ﻣﻨﺒﻊ ﻛﺎﻫﺶ ﻳﺎﻓﺘﻪ ﺑﺎ ‪ 2‬ﻧﻤﺎد در ﻣﻨﺘﻬﺎ اﻟﻴﻪ ﺳﻤﺖ راﺳﺖ ﺗﺸﻜﻴﻞ ﺷﻮد‪.‬‬

‫ﮔﺎم دوم در روش ﻫﺎﻓﻤﻦ رﻣﺰﮔﺬاري ﻫﺮ ﻣﻨﺒﻊ ﻛﺎﻫﺶ ﻳﺎﻓﺘﻪ ﺑﺎ ﻛﻮﭼﻜﺘﺮﻳﻦ ﻣﻨﺒﻊ و ﻛﺎر ﺑﺎ ﻣﻨﺒﻊ اﺻﻠﻲ اﺳﺖ‪ .‬رﻣﺰﻫﺎي دودوﻳﻲ ﺑﺎ ﺣﺪاﻗﻞ ﻃﻮل در‬

‫ﻣﻨﺒﻊﻫﺎي دو ﻧﻤﺎدي از ﻧﻤﺎدﻫﺎي ‪ 0‬و ‪ 1‬ﺗﺸﻜﻴﻞ ﻣﻲﺷﻮﻧﺪ‪ .‬ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﺗﺼﻮﻳﺮ ‪.6.2‬ب ﻣﻲﺑﻴﻨﻴﺪ‪ ،‬اﻳﻦ ﻧﻤﺎدﻫﺎ ﺑﻪ دو ﻧﻤﺎد ﺳﻤﺖ راﺳﺖ‬

‫ﺗﺨﺼﻴﺺ داده ﺷﺪهاﻧﺪ )اﻳﻦ ﺗﺨﺼﻴﺺ اﺧﺘﻴﺎري اﺳﺖ ﺑﺎ ﻣﻌﻜﻮسﺳﺎزي ﺗﺮﺗﻴﺐ ‪ 0‬و ‪ 1‬ﻧﻴﺰ ﻛﺎر ﺑﻪ ﻫﻤﻴﻦ ﺷﻜﻞ اﺟﺮا ﻣﻲﺷﻮد(‪ .‬وﻗﺘﻲ ﻧﻤﺎد ﻛﺎﻫﺶ‬

‫‪8‬‬
‫ﻳﺎﻓﺘﻪ ﻣﻨﺒﻊ ﺑﺎ اﺣﺘﻤﺎل ‪ 0.5‬ﺑﺎ ادﻏﺎم دو ﻧﻤﺎد در ﻣﻨﺒﻊ ﻛﺎﻫﺶ ﻳﺎﻓﺘﻪ ﺳﻤﺖ ﭼﭗ ﺗﻮﻟﻴﺪ ﻣﻲﺷﻮد ﺻﻔﺮي ﻛﻪ ﺑﺮاي رﻣﺰﮔﺬاري آن ﺑﻪ ﻛﺎر ﺑﺮده ﺷﺪه‬

‫اﺳﺖ ﺑﻪ ﻫﺮ دو ﻧﻤﺎد ﺗﺨﺼﻴﺺ داده ﻣﻲﺷﻮد و ‪ 0‬و ‪ 1‬ﻫﺮ ﻛﺪام اﺧﺘﻴﺎري ﺑﻪ ﻫﺮ ﻛﺪام از آﻧﻬﺎ ﻣﺘﺼﻞ ﻣﻲﺷﻮﻧﺪ ﺗﺎ ﺑﺘﻮان آﻧﻬﺎ را از ﻳﻜﺪﻳﮕﺮ ﺗﺸﺨﻴﺺ‬

‫داد‪.‬‬

‫ﺗﺼﻮﻳﺮ ‪ :6.2‬ﻫﺎﻓﻤﻦ )‪ (a‬ﻛﺎﻫﺶ ﻣﻨﺒﻊ )‪ (b‬روش ﺗﺨﺼﻴﺺ رﻣﺰﻫﺎ‬

‫اﻳﻦ ﻋﻤﻠﻴﺎت در ﻫﺮ ﻳﻚ از ﻣﻨﺎﺑﻊ ﻛﺎﻫﺶ ﻳﺎﻓﺘﻪ آﻧﻘﺪر ﺗﻜﺮار ﻣﻲﺷﻮد ﻛﻪ ﺑﻪ ﻣﻨﺒﻊ اﺻﻠﻲ دﺳﺖ ﻳﺎﺑﻨﺪ‪ .‬رﻣﺰ ﻧﻬﺎﻳﻲ در ﻣﻨﺘﻬﺎ اﻟﻴﻪ ﺳﻤﺖ ﭼﭗ ﺳﺘﻮن ‪3‬‬

‫در ﺗﺼﻮﻳﺮ ‪ (b).6.2‬دﻳﺪه ﻣﻲﺷﻮد‪.‬‬

‫رﻣﺰ ﻫﺎﻓﻤﻦ در ﺗﺼﻮﻳﺮ ‪.6.2‬ب و ﺟﺪول ‪ 6.1‬ﻳﻚ رﻣﺰ ﻓﻮري ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد ﻗﺎﺑﻞ رﻣﺰﮔﺸﺎﻳﻲ اﺳﺖ‪ .‬اﻳﻦ ﻳﻚ رﻣﺰ ﺑﻠﻮﻛﻲ اﺳﺖ زﻳﺮا ﻫﺮ ﻧﻤﺎد ﻣﻨﺒﻊ ﺑﻪ‬

‫ﺗﻮاﻟﻴﻬﺎي ﺛﺎﺑﺘﻲ از ﻧﻤﺎدﻫﺎي رﻣﺰ ﺗﺮﺳﻴﻢ ﻣﻲﺷﻮد‪ .‬از آن ﺟﻬﺖ ﻓﻮري اﺳﺖ ﻛﻪ ﻫﺮ ﻛﻠﻤﻪ رﻣﺰي در رﺷﺘﻪ ﻧﻤﺎدﻫﺎي رﻣﺰ ﻣﻲﺗﻮاﻧﺪ ﺑﺪون ﻣﺮﺟﻊﮔﺬاري‬

‫ﻧﻤﺎدﻫﺎي ﺑﻌﺪي رﻣﺰﮔﺸﺎﻳﻲ ﺷﻮد‪ .‬ﻳﻌﻨﻲ ﻛﻠﻤﺎت ﺑﺪون رﻣﺰ در ﻫﺮ ﻳﻚ از رﻣﺰﻫﺎي ﻫﺎﻓﻤﻦ ﺑﻪ ﺻﻮرت ﻳﻚ در ﻣﻴﺎن ﭘﻴﺸﻮﻧﺪ ﻛﻠﻤﺎت ﻫﺴﺘﻨﺪ‪ .‬آﻧﻬﺎ ﺑﻪ‬

‫ﺷﻜﻠﻲ ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد ﻗﺎﺑﻞ رﻣﺰﮔﺸﺎﻳﻲ ﻫﺴﺘﻨﺪ زﻳﺮا رﺷﺘﻪ ﻧﻤﺎدﻫﺎ را ﻓﻘﻂ در ﻳﻚ ﺟﻬﺖ ﻣﻲﺗﻮان رﻣﺰﮔﺸﺎﻳﻲ ﻛﺮد‪ .‬ﺑﻨﺎ ﺑﺮ اﻳﻦ ﺑﺮاي رﻣﺰﮔﺸﺎﻳﻲ ﻫﺮ‬

‫ﻳﻚ از ﻧﻤﺎدﻫﺎي رﻣﺰﮔﺬاري ﺷﺪه ﻫﺎﻓﻤﻦ ﻋﻨﺎﺻﺮ ﺗﺸﻜﻴﻞ ﺷﺪه در رﺷﺘﻪ از ﭼﭗ ﺑﻪ راﺳﺖ ﺑﺮرﺳﻲ ﻣﻲﺷﻮﻧﺪ‪ .‬در ﺗﺼﻮﻳﺮ ‪ 4*4‬در ﻣﺜﺎل ‪ 6.1‬ﻳﻚ‬

‫رﻣﺰﮔﺬاري ﺑﺎﻻ ﺑﻪ ﭘﺎﻳﻴﻦ و ﭼﭗ ﺑﻪ راﺳﺖ ﺑﺮ اﺳﺎس رﻣﺰ ﻫﺎﻓﻤﻦ در ﺗﺼﻮﻳﺮ ‪.6.2‬ب رﺷﺘﻪ ‪ 29‬ﺑﻴﺘﻲ زﻳﺮ را ﺗﻮﻟﻴﺪ ﻣﻲﻛﻨﺪ‪ .101010111111 :‬از‬

‫‪9‬‬
‫آﻧﺠﺎﺋﻲ ﻛﻪ از ﻳﻚ ﺑﻠﻮك رﻣﺰ ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد ﻓﻮري ﻗﺎﺑﻞ رﻣﺰﮔﺸﺎﻳﻲ اﺳﺘﻔﺎده ﻣﻲﻛﻨﻴﻢ ﻧﻴﺎزي ﺑﻪ درج ﺟﺪاﺳﺎز ﺑﻴﻦ ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي رﻣﺰﮔﺬاري‬

119 ‫ ﻳﺎ ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي‬a2 ‫ اﺳﺖ ﻛﻪ رﻣﺰ ﻧﻤﺎد‬1 ‫ در ﺑﺮرﺳﻲ رﺷﺘﻪ ﺣﺎﺻﻞ از آن از ﭼﭗ ﺑﻪ راﺳﺖ ﻣﻌﻠﻮم ﺷﺪ ﻛﻪ اوﻟﻴﻦ رﻣﺰ ﻣﻌﺘﺒﺮ‬.‫ﺷﺪه ﻧﻴﺴﺖ‬

‫ اﮔﺮ ﻛﺎر را ﺑﻪ ﻫﻤﻴﻦ ﻣﻨﻮال اداﻣﻪ دﻫﻴﻢ ﺑﺎﻻﺧﺮه ﺑﻪ ﻳﻚ‬.‫ اﺳﺖ‬123 ‫ اﺳﺖ ﻛﻪ ﻣﻄﺎﺑﻖ ﺑﺎ ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي‬010 ‫ ﻛﻠﻤﻪ رﻣﺰي ﻣﻌﺘﺒﺮ ﺑﻌﺪي‬.‫اﺳﺖ‬

.‫ در ﻣﺜﺎل ﻓﻮق اﺳﺖ‬f ‫ﺗﺼﻮﻳﺮ رﻣﺰﮔﺸﺎﻳﻲ ﺷﺪه ﻣﻲرﺳﻴﻢ ﻛﻪ ﻣﻌﺎدل‬

.‫ اﺟﺮا ﺷﺪﻧﺪ ﻫﺎﻓﻤﻦ ﻧﺎﻣﻴﺪه ﻣﻲﺷﻮﻧﺪ‬M ‫روﺷﻬﺎي ﻛﺎﻫﺶ ﻣﻨﺒﻊ و ﺗﺨﺼﻴﺺ رﻣﺰﻫﺎ ﻛﻪ در ﺑﺎﻻ ﺑﺎ ﺗﺎﺑﻊ‬
function CODE = huffman(p)
%HUFFMAN Builds a variable-length Huffman code for a symbol source.
% CODE = HUFFMAN(P) returns a Huffman code as binary strings in
% cell array CODE for input symbol probability vector P. Each word
% in CODE corresponds to a symbol whose probability is at the
% corresponding index of P.
%
% Based on huffman5 by Sean Danaher, University of North Umbria,
% Newcastle UK. Available at the MATLAB Central File Exchange:
% Category General DSP in Signal Processing and Communications.

% Check the input arguments for reasonableness.

error(nargchk(1, 1, nargin));
if (ndims(p) ~= 2) | (min(size(p)) > 1) | ~isreal(p) | ~isnumeric(p)
error('p must be a real numeric vector.');
end

% Global variable surviving all recursions of function 'makecode'

global CODE
CODE = cell(length(p), 1); % Init the global cell array

if length(p)>1 % When more than one symbol…

p = p / sum(p); % Normalize the input probabilities
s = reduce(p); % Do Huffman source symbol reductions
makecode(s, []); % Recursively generate the code
else
CODE = {'1'}; % Else, trivial one symbol case!
end;
%----------------------------------------------------------------------------------
----%
function s = reduce(p);
% Create a Huffman source reduction tree in a MATLAB cell structure
% by performing source symbol reductions until there are only two
% reduced symbols remaining
s = cell(length(p), 1);

% Generate a starting tree with symbol nodes 1, 2, 3, … to

% reference the symbol probabilities.
for I = 1:length(p)
s{i} = i;
end

while numel(s) > 2

[p, i] = sort(p); % Sort the symbol probabilities
p(2) = p(1) + p(2); % Merge the 2 lowest probabilities
p(1) = []; % and prune the lowest one

s = s(i); % Reorder tree for new probabilities

10
 ‫;}}‪s{2} = {s{1}, s{2‬‬ ‫‪% and merge & prune its nodes‬‬
‫;][ = )‪s(1‬‬ ‫‪% to match the probabilities‬‬
‫‪end‬‬
‫‪%----------------------------------------------------------------------------------‬‬
‫‪----%‬‬
‫)‪function makecode(sc, codeword‬‬
‫‪% Scan the nodes of a Huffman source reduction tree recursively to‬‬
‫‪% generate the indicated variable length code words.‬‬
‫‪% Global variable surviving all recursive calls‬‬
‫‪global CODE‬‬
‫)'‪if isa(sc, 'cell‬‬ ‫‪% For cell array nodes,‬‬
‫;)]‪makecode(sc{1}, [codeword 0‬‬ ‫‪% add a 0 if the 1st element‬‬
‫;)]‪makecode(sc{2}, [codeword 1‬‬ ‫‪% or a 1 if the 2nd‬‬
‫‪else‬‬ ‫‪% For leaf (numeric) nodes,‬‬
‫;)‪CODE{sc} = char('0' + codeword‬‬ ‫‪% create a char code string‬‬
‫‪end‬‬

‫در ﺧﻂ ﻓﺮﻣﺎن زﻳﺮ ﺑﺮاي ﺗﻮﻟﻴﺪ رﻣﺰ در ﺗﺼﻮﻳﺮ ‪ 6.2‬از ﻫﺎﻓﻤﻦ اﺳﺘﻔﺎده ﻣﻲﺷﻮد‪.‬‬
‫‪>> p = [0.1875‬‬ ‫‪0.5‬‬ ‫‪0.125‬‬ ‫;]‪0.1875‬‬
‫)‪>> c = Huffman(p‬‬

‫=‪c o‬‬
‫'‪'011‬‬
‫'‪'1‬‬
‫'‪'010‬‬
‫'‪'00‬‬

‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ داده ﺧﺮوﺟﻲ آراﻳﻪاي ﻧﻮﻳﺴﻪدار ﺑﺎ ﻃﻮل ﺗﻐﻴﻴﺮﭘﺬﻳﺮ اﺳﺖ ﻛﻪ ﻫﺮ ردﻳﻒ آن ﻳﻚ رﺷﺘﻪ از ﺻﻔﺮﻫﺎ و ﻳﻜﻬﺎ اﺳﺖ ﻛﻪ رﻣﺰ‬

‫دودوﻳﻲ ﻧﻤﺎد ﺷﺎﺧﺺ ﮔﺬاري ﺷﺪه ﻣﻄﺎﺑﻖ ﺑﺎ آن در ﭘﻲ اﺳﺖ‪ .‬ﻣﺜﻼً ‪ 010‬در اراﻳﻪ ﺷﺎﺧﺺ ‪ 3‬رﻣﺰ ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي ﺑﺎ اﺣﺘﻤﺎل ‪ 0.125‬اﺳﺖ‪.‬‬

‫ﺷﻨﺎﺳﻪ ورودي ‪ p‬در ﻗﺴﻤﺘﻬﺎي اول ﻫﺎﻓﻤﻦ )ﺑﺮدار اﺣﺘﻤﺎﻻت ﻧﻤﺎد ورودي ﻧﻤﺎدﻫﺎي رﻣﺰﮔﺬاري ﺷﺪه( از ﻧﻈﺮ ﻣﻌﻘﻮل ﺑﻮدن ﺑﺮرﺳﻲ ﻣﻲﺷﻮد و رﻣﺰ‬

‫ﺗﻐﻴﻴﺮﭘﺬﻳﺮ ﻛﻠﻲ ﺑﻪ ﺻﻮرت اراﻳﻪ ﺳﻠﻮﻟﻬﺎي ‪ MATLAB‬ﺑﺎ ‪ length‬ﺑﻪ اﻧﺪازه ‪ p‬ردﻳﻒ و ﻳﻚ ﺳﺘﻮن ﺗﻌﺮﻳﻒ ﺷﺪه اﺳﺖ ﺷﺮوع ﻣﻲﺷﻮد‪ .‬ﻛﻠﻴﻪ‬

‫ﻣﺘﻐﻴﺮﻫﺎي ﻛﻠﻲ ﻧﺮم اﻓﺰار ‪ MATLAB‬ﺑﺎﻳﺪ ﺑﺮ ﺣﺴﺐ ﺗﺎﺑﻌﻬﺎﻳﻲ ﺑﻴﺎن ﺷﻮﻧﺪ ﻛﻪ ﺑﺎ ﻋﺒﺎرﺗﻬﺎﻳﻲ ﺷﺒﻴﻪ ﺑﻪ ﻋﺒﺎرت زﻳﺮ ﻣﺮﺟﻊ ﮔﺬاري ﻣﻲﺷﻮﻧﺪ‪.‬‬
‫‪global X Y Z‬‬

‫در اﻳﻦ ﻋﺒﺎرت ﻣﺘﻐﻴﺮﻫﺎي ‪ y ،x‬و ‪ z‬ﻛﻪ در آﻧﻬﺎ ﺑﻴﺎن ﻣﻲﺷﻮﻧﺪ‪ ،‬وﻗﺘﻲ ﭼﻨﺪ ﺗﺎﺑﻊ ﻳﻚ ﻣﺘﻐﻴﺮ ﻛﻠﻲ را ﺑﻴﺎن ﻛﻨﻨﺪ‪ ،‬ﻳﻚ ﻧﺴﺨﻪ واﺣﺪي از آن ﻣﺘﻐﻴﺮ را‬

‫دارﻧﺪ‪ .‬ﺗﺎﺑﻊ داﺧﻠﻲ و ﻣﺘﺪاول ﻫﺎﻓﻤﻦ ﺑﺎ ﻧﺎم ‪ makecode‬ﺧﺼﻮﺻﻴﺎت ﻣﺸﺘﺮﻛﻲ ﺑﺎ ﻣﺘﻐﻴﺮ ﻛﻠﻲ ‪ code‬دارد‪ .‬ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﻣﻌﻤﻮﻻً اﺳﺎﻣﻲ‬

‫ﻣﺘﻐﻴﺮﻫﺎي ﻛﻠﻲ ﺑﺎ ﺣﺮوف ﺑﺰرگ ﻧﻮﺷﺘﻪ ﻣﻲﺷﻮد‪ .‬ﻣﺘﻐﻴﺮﻫﺎي ﻏﻴﺮﻛﻠﻲ ﻣﺘﻐﻴﺮﻫﺎي ﻣﻮﺿﻌﻲ ﻫﺴﺘﻨﺪ و ﻓﻘﻂ در اﺧﺘﻴﺎر ﺗﺎﺑﻌﻬﺎﻳﻲ ﻫﺴﺘﻨﺪ ﻛﻪ در آﻧﻬﺎ‬

‫ﺗﻌﺮﻳﻒ ﻣﻲﺷﻮﻧﺪ )ﻧﻪ در اﺧﺘﻴﺎر ﺳﺎﻳﺮ ﺗﺎﺑﻌﻬﺎ ﻳﺎ ﻓﻀﺎي ﻛﺎري ﻣﺒﻨﺎ(‪ .‬آﻧﻬﺎ ﻣﻌﻤﻮﻻً ﺑﺎ ﺣﺮوف ﻛﻮﭼﻚ ﻧﻮﺷﺘﻪ ﻣﻲﺷﻮﻧﺪ‪ .‬در ﻫﺎﻓﻤﻦ ﺑﺮاي اﺟﺮاي ‪code‬‬

‫از ﺗﺎﺑﻊ ‪ cell‬اﺳﺘﻔﺎده ﻣﻲﺷﻮد ﻛﻪ ﺗﺮﻛﻴﺐ آن ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ‪:‬‬

‫)‪X = cell(m, n‬‬

‫‪11‬‬
‫اﻳﻦ دﺳﺘﻮر‪،‬ﺗﻌﺪاد ‪ m*n‬آراﻳﻪ از ﻣﺎﺗﺮﻳﺴﻬﺎي ﺧﺎﻟﻲ اﻳﺠﺎد ﻣﻲﻛﻨﺪ ﻛﻪ ﺑﺮ اﺳﺎس ﺳﻠﻮل ﻳﺎ ﻣﺤﺘﻮا ﻣﺮﺟﻊ ﮔﺬاري ﻣﻲﺷﻮﻧﺪ‪ .‬ﭘﺮاﻧﺘﺰ ﺑﺮاي‬

‫ﺷﺎﺧﺺﮔﺬاري ﺳﻠﻮﻟﻬﺎ ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮد‪ .‬از ")(" ﺑﺮاي ﺷﺎﺧﺺﮔﺬاري ﻣﺤﺘﻮا اﺳﺘﻔﺎده ﻣﻲﺷﻮد ﺑﻨﺎ ﺑﺮ اﻳﻦ ][=)‪ x(1‬ﺷﺎﺧﺺ اﺳﺖ و ﻋﻨﺼﺮ ‪1‬‬

‫را از اراﻳﻪ ﺳﻠﻮﻟﻲ ﺑﺮﻣﻲدارد در ﺣﺎﻟﻲ ﻛﻪ ][ = }‪ x{1‬ﻣﺠﻤﻮﻋﻪ اوﻟﻴﻦ ﻋﻨﺼﺮ آراﻳﻪ ﺳﻠﻮل را در ﻣﺎﺗﺮﻳﺲ ﺧﺎﻟﻲ ﻗﺮار ﻣﻲدﻫﺪ‪.‬‬

‫ﻳﻌﻨﻲ }‪ x{1‬اﺷﺎره ﺑﻪ ﻣﺤﺘﻮﻳﺎت اوﻟﻴﻦ ﻋﻨﺼﺮ دارد‪ .‬آراﻳﻪ )‪ x: x(1‬ﺑﻴﺸﺘﺮ اﺷﺎره ﺑﻪ ﻋﻨﺼﺮ دارد ﺗﺎ ﻣﺤﺘﻮﻳﺎت آن‪ .‬از آﻧﺠﺎﺋﻲ ﻛﻪ ﻣﻲﺗﻮان آراﻳﻪﻫﺎي‬

‫ﺳﻠﻮﻟﻲ را در ﺳﺎﻳﺮ اراﻳﻪﻫﺎي ﺳﻠﻮﻟﻲ ﺗﻌﺒﻴﻪ ﻛﺮد ﺗﺮﻛﻴﺐ }‪ x{1}{2‬اﺷﺎره ﺑﻪ ﻣﺤﺘﻮاي ﻋﻨﺼﺮ دوم آراﻳﻪ ﺳﻠﻮﻟﻲ دارد ﻛﻪ در اوﻟﻴﻦ ﻋﻨﺼﺮ آراﻳﻪ‬

‫ﺳﻠﻮﻟﻲ اﻳﻜﺲ اﺳﺖ‪.‬ﭘﺲ از راه اﻧﺪازي ‪ code‬و ﻫﻨﺠﺎرﻣﻨﺪ ﻛﺮدن ﺑﺮدار اﺣﺘﻤﺎﻻت دادهﻫﺎي ورودي در ﻋﺒﺎرت )‪ p = p/sum (p‬ﻛﺪ ﻫﺎﻓﻤﻦ‬

‫ﺑﺮاي ﺑﺮدار اﺣﺘﻤﺎﻻت ﻫﻨﺠﺎرﻣﻨﺪ ﺷﺪه ﻃﻲ ‪ 2‬ﻣﺮﺣﻠﻪ اﻳﺠﺎد ﻣﻲﺷﻮد‪ .‬ﻣﺮﺣﻠﻪ اول ﻛﻪ ﺑﺎ ﻋﺒﺎرت اﺻﻠﻲ روال )‪ s=reduce (p‬راه اﻧﺪازي ﻣﻲﺷﻮد‪،‬‬

‫ﺗﺎﺑﻊ دروﻧﻲ ‪ reduce‬را ﻓﺮاﺧﻮاﻧﻲ ﻣﻲﻛﻨﺪ ﻛﻪ وﻇﻴﻔﻪ آن ﻛﺎﻫﺶ ﻣﻨﺒﻊ اﺳﺖ ﻛﻪ در ﺗﺼﻮﻳﺮ ‪(a).6.2‬دﻳﺪه ﻣﻲﺷﻮد‪ .‬در اﻳﻦ روﻧﺪ ﻋﻨﺎﺻﺮ اراﻳﻪ‬

‫ﺳﻠﻮﻟﻲ ﻛﻪ در اﺑﺘﺪا ﺧﺎﻟﻲ ﺑﻮده اﺳﺖ و ﺑﺎ ‪ code‬ﻣﻨﻄﺒﻖ ﺷﺪه اﺳﺖ ﺑﺎ ﺷﺎﺧﺼﻬﺎي ﻣﺮﺑﻮﻃﻪ راه اﻧﺪازي ﻣﻲﺷﻮﻧﺪ‪ .‬ﻳﻌﻨﻲ ‪ s{1}=1, s{2}=2‬و‬

‫ﻏﻴﺮه‪ .‬ﺳﭙﺲ ﺳﻠﻮل ﻣﻌﺎدل ﻧﻤﻮدار دودوﻳﻲ ﻛﺎﻫﺸﻬﺎي ﻣﻨﺒﻊ در ﺣﻠﻘﻪ ‪ while numel (s) > 2‬اﻳﺠﺎد ﻣﻲﺷﻮد‪ .‬در ﻫﺮ دﻓﻌﻪ ﺗﻜﺮار اﻳﻦ ﺣﻠﻘﻪ‬

‫ﺑﺮدار ‪ p‬ﺑﺮ ﺣﺴﺐ اﻓﺰاﻳﺶ اﺣﺘﻤﺎﻻت ﻣﺮﺗﺐ ﻣﻲﺷﻮد‪ .‬اﻳﻦ ﻛﺎر ﺑﺎ ﺗﺎﺑﻊ ‪) sort‬ﻳﻌﻨﻲ ﻣﺮﺗﺐ ﺳﺎزي( اﻧﺠﺎم ﻣﻲﺷﻮد ﻛﻪ ﺗﺮﻛﻴﺐ ﻛﻠﻲ آن ﺑﻪ ﺷﺮح زﻳﺮ‬

‫اﺳﺖ‪:‬‬
‫)‪[y, i] = sort(x‬‬

‫دادهﻫﺎي ﺧﺮوﺟﻲ ‪ y‬ﻋﻨﺎﺻﺮ ﻣﺮﺗﺐ ﺷﺪه اﻳﻜﺲ ﻫﺴﺘﻨﺪ و ‪ i‬ﻃﻮري اﺳﺖ ﻛﻪ )‪ y=x(i‬اﺳﺖ‪ .‬ﭘﺲ از ﻣﺮﺗﺐ ﺷﺪن ‪ p‬اﻳﻦ دو اﺣﺘﻤﺎل در )‪ p(2‬ﺑﺎ‬

‫ﻫﻢ ادﻏﺎم ﻣﻲﺷﻮﻧﺪ و )‪ p(1‬ﺑﺮﻳﺪه ﻣﻲﺷﻮد‪ .‬ﺳﭙﺲ ﺳﻠﻮل ﻛﺎﻫﺶ ﻣﻨﺒﻊ دوﺑﺎره ﻣﺮﺗﺐ ﻣﻲﺷﻮد ﺗﺎ ﻣﻨﻄﺒﻖ ﺑﺮ ‪ p‬ﺑﺮ اﺳﺎس ﺑﺮدار ﺷﺎﺧﺺ ‪ i‬ﺑﺎ اﺳﺘﻔﺎده‬

‫از )‪ s=s(i‬ﺑﺎﺷﺪ‪ .‬ﺑﺎﻻﺧﺮه }‪ s{2‬ﺑﺎ آراﻳﻪ ﺳﻠﻮﻟﻲ دو ﻋﻨﺼﺮي ﺣﺎوي ﺷﺎﺧﺼﻬﺎي اﺣﺘﻤﺎل ادﻏﺎم ﺷﺪه از ﻃﺮﻳﻖ }}‪ s{2}={s{1},s{2‬ﺟﺎﻳﮕﺰﻳﻦ‬

‫ﻣﻲﺷﻮد‪) .‬اﻳﻦ ﻳﻚ ﻧﻤﻮﻧﻪ از ﺷﺎﺧﺺﮔﺬاري ﻣﺤﺘﻮا اﺳﺖ(‪ .‬ﺷﺎﺧﺺﮔﺬاري ﺳﻠﻮل ﺑﺮاي ﺑﺮﻳﺪن اوﻟﻴﻦ ﻋﻨﺼﺮ از دو ﻋﻨﺼﺮ ادﻏﺎم ﺷﺪه )‪ s(1‬از‬

‫ﻃﺮﻳﻖ][=)‪ s(1‬ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮد‪ .‬اﻳﻦ ﻓﺮاﻳﻨﺪ آﻧﻘﺪر ﺗﻜﺮار ﻣﻲﺷﻮد ﺗﺎ ﻓﻘﻂ دو ﻋﻨﺼﺮ در ‪ s‬ﺑﺎﻗﻲ ﺑﻤﺎﻧﻨﺪ‪.‬‬
‫;)‪celldisp(s‬‬
‫;)‪cellplot(s‬‬

‫‪12‬‬
‫دادهﻫﺎي ﺧﺮوﺟﻲ ﻓﺮاﻳﻨﺪ اﺣﺘﻤﺎﻻت ﻧﻤﺎدﻫﺎ در ﺟﺪول ‪ 6.1‬و ﺗﺼﻮﻳﺮ ‪(a).6.2‬در ﺗﺼﻮﻳﺮ ‪ 6.3‬ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‪ .‬ﺗﺼﻮﻳﺮﻫﺎي ‪.6.3‬ب و ﺳﻲ ﺑﺎ‬

‫درج ﺑﻴﻦ ‪ 2‬ﻋﺒﺎرت آﺧﺮ روال اﺻﻠﻲ ﻫﺎﻓﻤﻦ اﻳﺠﺎد ﺷﺪﻧﺪ‪.‬‬

‫ﺗﺎﺑﻊ ‪ celldisp‬ﻧﺮم اﻓﺰار ‪ MATLAB‬ﻣﺤﺘﻮﻳﺎت آراﻳﻪ ﺳﻠﻮل را ﻣﻜﺮراٌ ﻧﻤﺎﻳﺶ ﻣﻲدﻫﺪ‪ .‬ﺗﺎﺑﻊ ‪ cellplot‬ﺗﺼﻮﻳﺮ ﮔﺮاﻓﻴﻜﻲ ﻳﻚ آراﻳﻪ ﺳﻠﻮﻟﻲ ﺑﻪ‬

‫ﺻﻮرت ﺟﻌﺒﻪﻫﺎي ﺗﻮدرﺗﻮ اﺳﺖ‪ .‬ﺑﻪ ﺗﻄﺎﺑﻖ ﻳﻚ ﺑﻪ ﻳﻚ ﻋﻨﺎﺻﺮ آراﻳﻪ ﺳﻠﻮﻟﻲ در ﺗﺼﻮﻳﺮ ‪.6.3‬ب و ﮔﺮهﻫﺎي درﺧﺖ ﻛﺎﻫﺶ ﻣﻨﺒﻊ در ﺗﺼﻮﻳﺮ ‪(a).6.3‬‬

‫ﺗﻮﺟﻪ ﻛﻨﻴﺪ‪.‬‬

‫)‪ (1‬ﻫﺮ ﻳﻚ از ﻣﺴﻴﺮﻫﺎي دو ﺷﺎﺧﻪ در اﻳﻦ ﻧﻤﻮدار )ﻛﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ ﻛﺎﻫﺶ ﻣﻨﺒﻊ اﺳﺖ( ﻣﻄﺎﺑﻖ ﺑﺎ ﻳﻚ اراﻳﻪ ﺳﻠﻮﻟﻲ دو ﻋﻨﺼﺮي در ‪ s‬اﺳﺖ‪.‬‬

‫)‪ (2‬ﻫﺮ ﻳﻚ از آراﻳﻪﻫﺎي ﺳﻠﻮﻟﻲ دو ﻋﻨﺼﺮي ﺣﺎوي ﺷﺎﺧﺼﻬﺎي ﻧﻤﺎدﻫﺎﻳﻲ اﺳﺖ ﻛﻪ در ﻛﺎﻫﺶ ﻣﻨﺒﻊ ﻣﻄﺎﺑﻖ ﺑﺎ آﻧﻬﺎ ادﻏﺎم ﺷﺪﻧﺪ‪.‬‬

‫ﻣﺜﻼً ادﻏﺎم ﻧﻤﺎدﻫﺎي ‪ a3 , a1‬در اﻧﺘﻬﺎي اﻳﻦ ﻧﻤﻮدار آراﻳﻪ ﺳﻠﻮﻟﻲ دو ﻋﻨﺼﺮي }‪ s{1}{2‬را اﻳﺠﺎد ﻣﻲﻛﻨﺪ‪ .‬در اﻳﻨﺠﺎ ‪ s{1}{2}{1}=3‬و‬

‫‪ s{1}{2}{2}=1‬ﺑﻪ ﺗﺮﺗﻴﺐ ﺷﺎﺧﺼﻬﺎي ﻧﻤﺎد ‪ a3, a1‬ﻫﺴﺘﻨﺪ‪ .‬رﻳﺸﻪ اﻳﻦ درﺧﺖ آراﻳﻪ ﺳﻠﻮﻟﻲ دو ﻋﻨﺼﺮي ﻓﻮﻗﺎﻧﻲ اﺳﺖ‪.‬‬

‫ﮔﺎم ﻧﻬﺎﻳﻲ در ﻓﺮاﻳﻨﺪ ﺗﻮﻟﻴﺪ رﻣﺰ )ﻳﻌﻨﻲ ﺗﺨﺼﻴﺺ رﻣﺰﻫﺎ ﺑﺮ اﺳﺎس آراﻳﻪ ﺳﻠﻮﻟﻲ ﻛﺎﻫﺶ ﻣﻨﺒﻊ ‪ (s‬ﺑﺎ ﻓﺮاﺧﻮاﻧﻲ ﻋﺒﺎرت ﻧﻬﺎﻳﻲ ﻫﺎﻓﻤﻦ ﻳﻌﻨﻲ‬

‫)][‪ makecode(s,‬اﺟﺮا ﻣﻲﺷﻮد‪ .‬اﻳﻦ ﻓﺮاﺧﻮاﻧﻲ ﺑﺎﻋﺚ راه اﻧﺪازي ﻓﺮاﻳﻨﺪ ﺗﺨﺼﻴﺺ رﻣﺰﻫﺎي ﺗﻜﺮاري ﺑﺮ اﺳﺎس روش ﺗﺼﻮﻳﺮ ‪ (b)6.2‬ﻣﻲﺷﻮد‪.‬‬

‫ﮔﺮﭼﻪ ﺗﻜﺮار ﺑﺎﻋﺚ ﺻﺮﻓﻪ ﺟﻮﻳﻲ در ذﺧﻴﺮه ﺳﺎزي )زﻳﺮا ﻣﻘﺎدﻳﺮ ﭘﺮدازش ﺷﺪه ﺑﺎﻳﺪ ﺟﺎي دﻳﮕﺮ ﻧﮕﻬﺪاري ﺷﻮﻧﺪ( و ﻳﺎ اﻓﺰاﻳﺶ ﺳﺮﻋﺖ ﻧﻤﻲﺷﻮد وﻟﻲ‬

‫ﻣﺰﻳﺘﺶ آن اﺳﺖ ﻛﻪ رﻣﺰ ﻓﺸﺮده اﺳﺖ و درك آن آﺳﺎن اﺳﺖ ﻣﺨﺼﻮﺻﺎً ﻫﻨﮕﺎم ﻛﺎر ﺑﺎ دادهﻫﺎﻳﻲ ﻛﻪ ﺑﻪ ﺷﻜﻞ ﺗﻜﺮاري ﺗﻌﺮﻳﻒ ﺷﺪهاﻧﺪ ﻣﺎﻧﻨﺪ‬

‫ﻧﻤﻮدارﻫﺎي درﺧﺘﻲ‪ .‬ﻫﺮ ﻳﻚ از ﺗﺎﺑﻌﻬﺎي ﻧﺮم اﻓﺰار ‪ MATLAB‬را ﻣﻲﺗﻮان ﺑﻪ ﺻﻮرت ﺗﻜﺮاري اﺳﺘﻔﺎده ﻛﺮد ﻳﻌﻨﻲ ﻣﻲﺗﻮان آﻧﻬﺎ را ﻣﺴﺘﻘﻴﻤﺎً ﻳﺎ‬

‫ﻏﻴﺮﻣﺴﺘﻘﻴﻢ ﻓﺮاﺧﻮاﻧﻲ ﻛﺮد‪ .‬ﻫﻨﮕﺎم ﺑﺎزﮔﺸﺖ در ﻓﺮاﺧﻮاﻧﻲ ﺗﺎﺑﻌﻬﺎ ﻣﺠﻤﻮﻋﻪ ﺗﺎزهاي از ﻣﺘﻐﻴﺮﻫﺎي ﻣﻮﺿﻌﻲ اﻳﺠﺎد ﻣﻲﺷﻮﻧﺪ ﻛﻪ ﻣﺴﺘﻘﻞ از ﻫﻤﻪ‬

‫ﻣﺠﻤﻮﻋﻪﻫﺎي ﻗﺒﻠﻲ ﻫﺴﺘﻨﺪ‪.‬‬

‫ﺗﺎﺑﻊ دروﻧﻲ ‪ makecode‬دو ﻧﻮع داده ورودي را ﻗﺒﻮل ﻣﻲﻛﻨﺪ‪ codeword :‬ﻛﻪ آراﻳﻪاي از ﺻﻔﺮﻫﺎ و ﻳﻜﻬﺎ اﺳﺖ و ‪ sc‬ﻛﻪ ﻋﻨﺼﺮ آراﻳﻪ ﺳﻠﻮﻟﻲ‬

‫ﻛﺎﻫﺶ ﻣﻨﺒﻊ اﺳﺖ‪ .‬وﻗﺘﻲ ‪ sc‬ﺧﻮدش ﻳﻚ اراﻳﻪ ﺳﻠﻮﻟﻲ ﺑﺎﺷﺪ‪ ،‬ﺣﺎوي دو ﻧﻤﺎد )ﺗﺮﻛﻴﺒﻲ( ﻣﻨﺒﻊ اﺳﺖ ﻛﻪ در ﻓﺮاﻳﻨﺪ ﻛﺎﻫﺶ ﻣﻨﺒﻊ ﺑﺎ ﻳﻜﺪﻳﮕﺮ ادﻏﺎم‬

‫ﺷﺪهاﻧﺪ‪ .‬از آﻧﺠﺎﺋﻲ ﻛﻪ آﻧﻬﺎ ﺑﺎﻳﺪ اﻧﻔﺮادي رﻣﺰﮔﺬاري ﺷﻮﻧﺪ‪ mkecode ،‬ﻣﻜﺮراٌ در ﻋﻨﺎﺻﺮ ﻓﺮاﺧﻮاﻧﻲ ﻣﻲﺷﻮد ﻛﻪ ﻫﻤﺮاه ﺑﺎ دو ﻛﻠﻤﻪ رﻣﺰي اﺳﺖ ﻛﻪ‬

‫روزﻳﻨﻪ ﻣﻲﺷﻮﻧﺪ )ﺻﻔﺮﻫﺎ و ﻳﻚ ﺑﻪ ﻛﻠﻤﻪ رﻣﺰ ورودي ﺿﻤﻴﻤﻪ ﻣﻲﺷﻮﻧﺪ‪ .‬وﻗﺘﻲ ‪ sc‬ﺣﺎوي اراﻳﻪ ﺳﻠﻮل ﻧﺒﺎﺷﺪ‪ ،‬ﺷﺎﺧﺺ ﻧﻤﺎد ﻣﻨﺒﻊ اﺻﻠﻲ اﺳﺖ و‬

‫رﺷﺘﻪ دودوﻳﻲ اﻳﺠﺎد ﺷﺪه از ﻛﻠﻤﻪ رﻣﺰ ورودي ﺑﺎ اﺳﺘﻔﺎده از )‪ code (sc) = char (0 +codeword‬ﺑﻪ آن ﺗﺨﺼﻴﺺ داده ﻣﻲﺷﻮد‪ .‬ﻫﻤﺎن‬

‫ﻃﻮر ﻛﻪ ﮔﻔﺘﻴﻢ‪ ،‬ﺗﺎﺑﻊ ‪ char‬در ﻧﺮم اﻓﺰار ‪ MATLAB‬آراﻳﻪﻫﺎي ﺣﺎوي اﻋﺪاد ﺻﺤﻴﺢ ﻣﺜﺒﺖ را ﻛﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ رﻣﺰﻫﺎي ﻧﻮﻳﺴﻪ ﻫﺴﺘﻨﺪ ﺑﻪ آراﻳﻪ‬

‫‪13‬‬
‫ﻧﻮﻳﺴﻪ ‪ MATLAB‬ﺗﺒﺪﻳﻞ ﻣﻲﻛﻨﺪ )‪ 127‬رﻣﺰ اول اﺳﻜﻲ ﻫﺴﺘﻨﺪ(‪ .‬ﻣﺜﻼً )]‪ char(‘0’+[010‬رﺷﺘﻪ ’‪ ‘010‬را ﺗﻮﻟﻴﺪ ﻣﻲﻛﻨﺪ زﻳﺮا اﻓﺰودن‬

‫ﺻﻔﺮ ﺑﻪ ﻛﺪ اﺻﻠﻲ ﺑﻪ ازاي ﻫﺮ ﺻﻔﺮ ﻳﻚ ﺻﻔﺮ اﺳﻜﻲ ﺗﻮﻟﻴﺪ ﻣﻲﻛﻨﺪ در ﺣﺎﻟﻲ ﻛﻪ اﻓﺰودن ‪ 1‬ﺑﻪ اﺳﻜﻲ ﺻﻔﺮ ﻓﻘﻂ ﻛﺪ اﺳﻜﻲ ‪ 1‬را اﻳﺠﺎد ﻣﻲﻛﻨﺪ‪.‬‬

‫در ﺟﺪول ‪ 6.2‬ﺟﺰﺋﻴﺎت روال ﻓﺮاﺧﻮاﻧﻲ ‪ makecode‬ﻛﻪ ﻧﺘﺎﻳﺞ آن در آراﻳﻪ ﺳﻠﻮﻟﻲ ﻛﺎﻫﺶ ﻣﻨﺒﻊ ﺗﺼﻮﻳﺮ ‪ 6.3‬دﻳﺪه ﻣﻲﺷﻮد‪ .‬ﺑﺮاي رﻣﺰﮔﺬاري‬

‫ﭼﻬﺎر ﻧﻤﺎد ﻣﻨﺒﻊ ﻫﻔﺖ ﻓﺮاﺧﻮاﻧﻲ ﻣﻮرد ﻧﻴﺎز اﺳﺖ‪ .‬اوﻟﻴﻦ ﻓﺮاﺧﻮاﻧﻲ )ردﻳﻒ ‪ 1‬ازﺟﺪول ‪ (6.2‬از روال اﺻﻠﻲ ﻫﺎﻓﻤﻦ اﻧﺠﺎم ﻣﻲﺷﻮد و ﻓﺮاﻳﻨﺪ‬

‫رﻣﺰﮔﺬاري را ﺑﺎ دادهﻫﺎي ورودي ﻛﻠﻤﻪ رﻣﺰ راه اﻧﺪازي ﻣﻲﻛﻨﺪ و ‪ sc‬ﺑﻪ ﺗﺮﺗﻴﺐ ﺑﻪ ﻣﺎﺗﺮﻳﺲ ﺧﺎﻟﻲ و آراﻳﻪ ﺳﻠﻮﻟﻲ ‪ s‬ﺗﺨﺼﻴﺺ داده ﻣﻲﺷﻮد‪.‬‬

‫}‪ {1*2cell‬ﺑﺮ اﺳﺎس ﻧﺸﺎﻧﻪﮔﺬارﻳﻬﺎي ﻧﺮم اﻓﺰار ‪ MATLAB‬ﺑﻪ ﻣﻌﻨﻲ آراﻳﻪ ﺳﻠﻮﻟﻲ ﺗﻚ ردﻳﻔﻪ دو ﺳﺘﻮﻧﻲ اﺳﺖ‪ .‬از آﻧﺠﺎﺋﻲ ﻛﻪ ‪ sc‬ﻫﻤﻴﺸﻪ‬

‫آراﻳﻪ ﺳﻠﻮﻟﻲ در اوﻟﻴﻦ ﻓﺮاﺧﻮاﻧﻲ اﺳﺖ )ﻣﻨﺒﻊ ﻧﻤﺎد ﺗﻜﻲ ﻳﻚ اﺳﺘﺜﻨﺎ اﺳﺖ( دو ﻓﺮاﺧﻮاﻧﻲ ﻣﻜﺮر ردﻳﻔﻬﺎي ‪ 2‬و ‪ 7‬ﺟﺪول اﻧﺠﺎم ﻣﻲﺷﻮد‪ .‬اوﻟﻴﻦ‬

‫ﻓﺮاﺧﻮاﻧﻲ دو ﻓﺮاﺧﻮاﻧﻲ دﻳﮕﺮ را ﻧﻴﺰ راه اﻧﺪازي ﻣﻲﻛﻨﺪ ﻛﻪ ردﻳﻔﻬﺎي ‪ 3‬و ‪ 4‬ﻫﺴﺘﻨﺪ‪ .‬و دوﻣﻴﻦ ﻣﻮرد ردﻳﻔﻬﺎي ‪ 5‬و ‪ 6‬را ﻓﺮاﺧﻮاﻧﻲ ﻣﻲﻛﻨﺪ‪.‬‬

‫ﺟﺪول ‪ :6.2‬ﻓﺮاﻳﻨﺪ ﺗﺨﺼﻴﺺ رﻣﺰ در اراﻳﻪ ﺳﻠﻮﻟﻲ ﻛﺎﻫﺶ ﻣﻨﺒﻊ در ﺗﺼﻮﻳﺮ ‪6.3‬‬

‫ﻫﺮ دﻓﻌﻪ ﻛﻪ ‪ sc‬ﻳﻚ اراﻳﻪ ﺳﻠﻮﻟﻲ ﻧﺒﺎﺷﺪ‪ ،‬ﻫﻤﭽﻮن ردﻳﻔﻬﺎي ‪ 6 ،5 ،3‬و ‪ 7‬ﺟﺪول ﺗﻜﺮارﻫﺎي اﺿﺎﻓﻲ ﺑﺎﻳﺪ اﻧﺠﺎم ﺷﻮﻧﺪ‪ .‬رﺷﺘﻪ رﻣﺰ از ‪codeword‬‬

‫اﻳﺠﺎد ﻣﻲﺷﻮد و ﺑﻪ ﻧﻤﺎد ﻣﻨﺒﻌﻲ ﺗﺨﺼﻴﺺ داده ﻣﻲﺷﻮد ﻛﻪ ﺷﺎﺧﺺ آن ‪ sc‬ﺑﻮده اﺳﺖ‪.‬‬

‫‪ .6.2.2‬رﻣﺰﮔﺬاري ﻫﺎﻓﻤﻦ ) ‪(Huffman Encoder‬‬

‫رﻣﺰﮔﺬاري ﻫﺎﻓﻤﻦ ﺑﻪ ﺧﻮدي ﺧﻮد ﻓﺸﺮدهﺳﺎزي ﻣﺤﺴﻮب ﻧﻤﻲﺷﻮد‪ .‬ﺑﺮاي درك روش ﻓﺸﺮدهﺳﺎزي ﺗﻌﺒﻴﻪ ﺷﺪه در رﻣﺰﻫﺎي ﻫﺎﻓﻤﻦ ﻧﻤﺎدﻫﺎﻳﻲ ﻛﻪ‬

‫رﻣﺰﻫﺎ در آن اﻳﺠﺎد ﺷﺪه اﺳﺖ ﭼﻪ از ﻧﻮع ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﺑﺎﺷﻨﺪ و ﻳﺎ دادهﻫﺎي ﺧﺮوﺟﻲ ﺳﺎﻳﺮ ﻋﻤﻠﻴﺎت ﺗﺮﺳﻴﻢ ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﺑﺎﺷﻨﺪ ﺑﺎﻳﺪ‬

‫ﻣﻄﺎﺑﻖ ﺑﺎ رﻣﺰﻫﺎي ﺗﻮﻟﻴﺪ ﺷﺪه ﺗﺒﺪﻳﻞ ﻳﺎ ﻧﻘﺸﻪ ﺑﺮداري )ﻳﻌﻨﻲ رﻣﺰﮔﺬاري( ﺷﻮﻧﺪ‪.‬‬

‫ﻣﺜﺎل ‪:6.2‬‬

‫ﻳﻚ ﺗﺼﻮﻳﺮ ﺳﺎده ‪ 4*4‬ﺷﺎﻧﺰده ﺑﺎﻳﺘﻲ را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪:‬‬

‫‪14‬‬
‫‪>> f2 = uint8([2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫;‪2‬‬ ‫‪3‬‬ ‫‪2‬‬ ‫‪4‬‬ ‫;‪4‬‬ ‫‪2‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫;‪2‬‬ ‫‪1‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫)]‪2‬‬
‫= ‪f2‬‬
‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪2‬‬
‫‪3‬‬ ‫‪2‬‬ ‫‪4‬‬ ‫‪4‬‬
‫‪2‬‬ ‫‪2‬‬ ‫‪1‬‬ ‫‪2‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪2‬‬
‫)'‪>> whos('f2‬‬
‫‪Name‬‬ ‫‪Size‬‬ ‫‪Bytes‬‬ ‫‪Class‬‬
‫‪F2‬‬ ‫‪4×4‬‬ ‫‪16‬‬ ‫‪uint8 array‬‬
‫‪Grand total is 16‬‬ ‫‪elements using 16 bytes‬‬

‫ﻫﺮ ﻋﻨﺼﺮ ﺗﺼﻮﻳﺮي در ‪ f2‬ﻳﻚ ﺑﺎﻳﺖ ﺣﺎوي ‪ 8‬ﺑﻴﺖ اﺳﺖ‪ .‬ﺑﺮاي ﻧﻤﺎﻳﺶ ﻛﻞ ﺗﺼﻮﻳﺮ از ‪ 16‬ﺑﺎﻳﺖ اﺳﺘﻔﺎده ﻣﻲﺷﻮد‪ .‬از آﻧﺠﺎﺋﻲ ﻛﻪ ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي‬

‫‪ f2‬اﺣﺘﻤﺎﻻت ﻳﻜﺴﺎن ﻧﺪارﻧﺪ‪ ،‬ﻳﻚ رﻣﺰ ﺑﺎ ﻃﻮل ﻣﺘﻐﻴﺮ )ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﺑﺨﺶ آﺧﺮ ﮔﻔﺘﻴﻢ( ﻣﻘﺪار ﺣﺎﻓﻈﻪ ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ﻧﻤﺎﻳﺶ ﺗﺼﻮﻳﺮ را‬

‫ﻛﺎﻫﺶ ﻣﻲدﻫﺪ‪ .‬ﺗﺎﺑﻊ ﻫﺎﻓﻤﻦ ﭼﻨﻴﻦ رﻣﺰي را ﻣﺤﺎﺳﺒﻪ ﻣﻲﻛﻨﺪ‪.‬‬

‫))‪>> c = Huffman(hist(double(f2(:)), 4‬‬
‫= ‪c‬‬
‫'‪'011‬‬
‫'‪'1‬‬
‫'‪'010‬‬
‫'‪'00‬‬

‫از آﻧﺠﺎﺋﻲ ﻛﻪ رﻣﺰﻫﺎي ﻫﺎﻓﻤﻦ ﺑﺮ اﺳﺎس ﺗﻌﺪاد دﻓﻌﺎت ﻧﺴﺒﻲ وﻗﻮع ﻧﻤﺎدﻫﺎي ﻣﻨﺒﻊ رﻣﺰﮔﺬاري ﺷﺪه ﻫﺴﺘﻨﺪ ﻧﻪ ﺧﻮد ﻧﻤﺎدﻫﺎ‪ c ،‬ﻣﺎﻧﻨﺪ رﻣﺰي اﺳﺖ‬

‫ﻛﻪ ﺑﺮاي ﺗﺼﻮﻳﺮ ﻣﺜﺎل ‪ 6.1‬اﻳﺠﺎد ﺷﺪ‪ .‬در واﻗﻊ ﻣﻲﺗﻮان ﺑﺎ ﺗﺮﺳﻴﻢ ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ‪107‬و ‪ ،123 ،119‬و ‪ 168‬ﺑﻪ ﺗﺮﺗﻴﺐ ﺗﺎ ‪ 3 ،2 ،1‬و ‪ 4‬ﺗﺼﻮﻳﺮ‬

‫‪ f2‬را از ‪ f‬در ﻣﺜﺎل ‪ 6.1‬ﺑﻪ دﺳﺖ آورد‪.‬‬

‫ﻳﻚ روش ﺳﺎده ﺑﺮاي رﻣﺰﮔﺬاري اف‪ 2‬ﺑﺮ اﺳﺎس رﻣﺰ ‪ c‬اﺟﺮاي ﻋﻤﻠﻴﺎت ﺟﺴﺘﺠﻮي ﺳﺎده اﺳﺖ‪.‬‬
‫'))‪>> h1f2 = c(f2(:‬‬
‫= ‪h1f2‬‬
‫‪Columns 1 through 9‬‬
‫'‪'1‬‬ ‫'‪'010' '1‬‬ ‫'‪'011' '010' '1‬‬ ‫'‪'1‬‬ ‫'‪'011' '00‬‬
‫‪Columns 10 through 16‬‬
‫'‪'00' '011' '1‬‬ ‫'‪'1‬‬ ‫'‪'00' '1‬‬ ‫'‪'1‬‬
‫)'‪>> whos('h1f2‬‬
‫‪Name‬‬ ‫‪Size‬‬ ‫‪Bytes‬‬ ‫‪Class‬‬
‫‪h1f2‬‬ ‫‪1×16‬‬ ‫‪1530‬‬ ‫‪cell array‬‬
‫‪Grand total is 45 elements using 1530 bytes‬‬

‫در اﻳﻨﺠﺎ ‪ f2‬ﻳﻚ اراﻳﻪ دو ﺑﻌﺪي از ﻧﻮع ‪ uint8‬اﺳﺖ ﻛﻪ ﺑﻪ اراﻳﻪ ﺳﻠﻮل ‪ 16*1‬ﺗﺒﺪﻳﻞ ﻣﻲﺷﻮد ‪ h1f2‬ﺟﺎﺑﺠﺎﻳﻲ اﺳﺖ ﻛﻪ ﻻﻳﻪ را ﻓﺸﺮده ﻣﻲﻛﻨﺪ‪.‬‬

‫ﻋﻨﺎﺻﺮ ‪ h1f2‬رﺷﺘﻪﻫﺎﻳﻲ ﺑﺎ ﻃﻮل ﻣﺘﻐﻴﺮ ﻫﺴﺘﻨﺪ ﻛﻪ ﻣﻄﺎﺑﻖ ﺑﺎ ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي ‪ f2‬از ﺑﺎﻻ ﺑﻪ ﭘﺎﻳﻴﻦ و ﭼﭗ ﺑﻪ راﺳﺖ ﺑﺮرﺳﻲ ﻣﻲﺷﻮﻧﺪ‪ .‬در اﻳﻦ‬

‫ﺗﺼﻮﻳﺮ رﻣﺰﮔﺬاري ﺷﺪه از ‪ 1530‬ﺑﺎﻳﺖ اﺳﺘﻔﺎده ﻣﻲﺷﻮد ﻛﻪ ‪ 100‬ﺑﺮاﺑﺮ ﺣﺎﻓﻈﻪ ﻣﻮرد ﻧﻴﺎز ﺗﻮﺳﻂ ‪ f2‬ﻫﺴﺘﻨﺪ‪.‬‬

‫اﺳﺘﻔﺎده از اراﻳﻪ ﺳﻠﻮﻟﻲ ‪ h1f2‬ﻣﻨﻄﻘﻲ اﺳﺖ ﭼﻮن ﻛﻪ ﻳﻜﻲ از ﺳﺎزهﻫﺎي اﺳﺘﺎﻧﺪارد دادهﻫﺎي ‪ MATLAB‬اﺳﺖ ﻛﻪ ﺑﺮاي ﻛﺎر ﺑﺎ آراﻳﻪﻫﺎي‬

‫دادهﻫﺎي ﻧﺎﻣﺸﺎﺑﻪ ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮد‪ .‬اﻳﻦ اﺧﺘﻼف در ﻣﻮرد ‪ h1f2‬ﻣﺮﺑﻮط ﺑﻪ ﻃﻮل رﺷﺘﻪﻫﺎي ﻧﻮﻳﺴﻪ اﺳﺖ و ﺑﻬﺎي ﭘﺮداﺧﺖ ﺷﺪه ﺑﺮاي ﻛﺎر ﺑﺎ آن‬

‫‪15‬‬
‫از ﻃﺮﻳﻖ آراﻳﻪ ﺳﻠﻮﻟﻲ ﺟﺰو ﻫﺰﻳﻨﻪﻫﺎي ﻋﻤﻮﻣﻲ ﺣﺎﻓﻈﻪ ﻣﺤﺴﻮب ﻣﻲﺷﻮد )ﻛﻪ در آراﻳﻪ ﺳﻠﻮﻟﻲ درج ﺷﺪه اﺳﺖ( ﻛﻪ ﺑﺮاي ردﻳﺎﺑﻲ ﻣﻮﻗﻌﻴﺖ‬

‫ﻋﻨﺎﺻﺮي ﺑﺎ ﻃﻮل ﻣﺘﻐﻴﺮ ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮد‪ .‬ﺑﺎ ﺗﺒﺪﻳﻞ ‪ h1f2‬ﺑﻪ ﻳﻚ آراﻳﻪ ﻧﻮﻳﺴﻪ دو ﺑﻌﺪي ﻣﺘﻌﺎرف ﻣﻲﺗﻮان از ﻫﺰﻳﻨﻪﻫﺎي ﻋﻤﻮﻣﻲ اﺟﺘﻨﺎب ﻛﺮد‪.‬‬
‫')‪>> h2f2 = char(h1f2‬‬
‫= ‪h2f2‬‬
‫‪1010011000011011‬‬
‫‪1 11‬‬ ‫‪1001‬‬ ‫‪0‬‬
‫‪0 10‬‬ ‫‪1‬‬ ‫‪1‬‬
‫)'‪>> whos('h2f2‬‬
‫‪Name‬‬ ‫‪Size‬‬ ‫‪Bytes‬‬ ‫‪Class‬‬
‫‪h2f2‬‬ ‫‪3×16‬‬ ‫‪96‬‬ ‫‪char array‬‬
‫‪Grand total is 48 elements using 96 bytes‬‬

‫در اﻳﻨﺠﺎ آراﻳﻪ ﺳﻠﻮﻟﻲ ‪ h1f2‬ﺑﻪ آراﻳﻪ ﻧﻮﻳﺴﻪ ‪ h2f2 16*3‬ﺗﺒﺪﻳﻞ ﻣﻲﺷﻮد‪ .‬ﻫﺮ ﺳﺘﻮن از ‪ h2f2‬ﻣﻄﺎﺑﻖ ﺑﺎ ﻳﻚ ﻋﻨﺼﺮ ﺗﺼﻮﻳﺮي از ‪ f2‬اﺳﺖ ﻛﻪ از‬

‫ﺑﺎﻻ ﺑﻪ ﭘﺎﻳﻴﻦ و ﭼﭗ ﺑﻪ راﺳﺖ ﺑﺮرﺳﻲ ﻣﻲﺷﻮﻧﺪ‪ .‬ﺑﻠﻮﻛﻬﺎ ﺑﺮاي اﻧﺪازه ﮔﻴﺮي ﺻﺤﻴﺢ آراﻳﻪ درج ﻣﻲﺷﻮﻧﺪ از آﻧﺠﺎﺋﻲ ﻛﻪ ﺑﺮاي ﻫﺮ ‪ 0‬و ‪ 1‬ﻛﻠﻤﻪ رﻣﺰ ﺑﻪ‬

‫دو ﺑﺎﻳﺖ ﻧﻴﺎز اﺳﺖ ﻛﻞ ﺣﺎﻓﻈﻪ ﻣﻮرد اﺳﺘﻔﺎده ﺗﻮﺳﻂ ‪ 96 h2f2‬ﺑﺎﻳﺖ اﺳﺖ ﻛﻪ ‪ 6‬ﻣﺮﺗﺒﻪ ﺑﻴﺸﺘﺮ از ‪ 16‬ﺑﺎﻳﺖ اﺻﻠﻲ ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ‪ f2‬اﺳﺖ‪.‬‬

‫ﻣﻲﺗﻮان ﻓﻀﺎﻫﺎي ﺧﺎﻟﻲ درج ﺷﺪه را ﺑﺎ اﺳﺘﻔﺎده از رواﺑﻂ زﻳﺮ ﺣﺬف ﻛﺮد‪:‬‬
‫;)‪>> h2f2 = h2f2(:‬‬
‫;] [ = )' ' == ‪>> h2f2(h2f2‬‬
‫)'‪>> whos('h2f2‬‬
‫‪Name‬‬ ‫‪Size‬‬ ‫‪Bytes‬‬ ‫‪Class‬‬
‫‪h2f2‬‬ ‫‪29×1‬‬ ‫‪58‬‬ ‫‪char array‬‬
‫‪Grand total is 29 elements using 58 bytes‬‬

‫وﻟﻲ ﺣﺎﻓﻈﻪ ﻣﻮرد ﻧﻴﺎز ﺑﻴﺸﺘﺮ از ‪ 16‬ﺑﺎﻳﺖ اﺻﻠﻲ ‪ f2‬اﺳﺖ‪.‬‬

‫ﺑﺮاي ﻓﺸﺮدهﺳﺎزي ‪ f2‬رﻣﺰ ‪ c‬ﺑﺎﻳﺪ در ﺳﻄﺢ ﺑﻴﺖ اﻋﻤﺎل ﺷﻮد و ﭼﻨﺪﻳﻦ ﻋﻨﺼﺮ ﺗﺼﻮﻳﺮي رﻣﺰﮔﺬاري ﺷﺪه در ﻳﻚ ﺑﺎﻳﺖ ﺟﻤﻊ ﺷﻮﻧﺪ‪.‬‬
‫)‪>> h3f2 = mat2huff(f2‬‬
‫=‪h3f2‬‬
‫]‪size: [4 4‬‬
‫‪min: 32769‬‬
‫]‪hist: [3 8 2 3‬‬
‫]‪code: [43867 1944‬‬

‫)'‪>> whos('h3f2‬‬
‫‪Name‬‬ ‫‪Size‬‬ ‫‪Bytes‬‬ ‫‪Class‬‬
‫‪h3f2‬‬ ‫‪1×1‬‬ ‫‪518‬‬ ‫‪struct array‬‬
‫‪Grand total is 13 elements using 518 bytes‬‬

‫ﮔﺮﭼﻪ ﺗﺎﺑﻊ ‪ mat2huff‬ﺳﺎﺧﺘﺎر ‪ h3f2‬را ﺗﻮﻟﻴﺪ ﻣﻲﻛﻨﺪ ﻛﻪ ﻧﻴﺎز ﺑﻪ ‪ 518‬ﺑﺎﻳﺖ ﺣﺎﻓﻈﻪ دارد اﻛﺜﺮ آن ﺑﺎ ﻳﻜﻲ از دو ﻣﻮرد زﻳﺮ ﻣﺮﺗﺒﻂ اﺳﺖ‪(1) :‬‬

‫ﻫﺰﻳﻨﻪﻫﺎي ﻋﻤﻮﻣﻲ ﻣﺘﻐﻴﺮ ﺳﺎزه )اﺳﺘﻔﺎده از ‪ imratio‬در ﺑﺨﺶ ‪ 6.1‬ﺑﺮاي ﻳﺎدآوري اﻳﻦ ‪ MATLAB‬ﻛﻪ ﻧﺮم اﻓﺰار ‪ MATLAB‬در ﻫﺮ‬

‫ﻣﻴﺪان از ﺳﺎزه از ‪ 124‬ﺑﺎﻳﺖ ﺑﺮاي ﻫﺰﻳﻨﻪﻫﺎي ﻋﻤﻮﻣﻲ اﺳﺘﻔﺎده ﻣﻲﻛﻨﺪ( و )‪ mat2huff (2‬اﻃﻼﻋﺎﺗﻲ ﺑﺮاي ﺗﺴﻬﻴﻞ رﻣﺰﮔﺸﺎﻳﻴﻬﺎي آﺗﻲ ﺗﻮﻟﻴﺪ‬

‫‪16‬‬
‫ را‬f2 ،mat2huff ‫ ﺻﺮف ﻧﻈﺮ از اﻳﻦ ﻫﺰﻳﻨﻪﻫﺎي ﻋﻤﻮﻣﻲ ﻛﻪ ﻫﻨﮕﺎم ﺑﺮرﺳﻲ ﺗﺼﻮﻳﺮﻫﺎي ﻛﺎرﺑﺮدي ﺑﺎ اﻧﺪازه ﻋﺎدي ﻗﺎﺑﻞ ﭼﺸﻢ ﭘﻮﺷﻲ اﺳﺖ‬.‫ﻣﻲﻛﻨﺪ‬

:‫ ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ‬h3f2 ‫ ﺑﻴﺘﻲ ﻓﺸﺮده ﻣﻲﺷﻮﻧﺪﻋﻨﺎﺻﺮ رﻣﺰ‬16 ‫ ﻛﻠﻤﻪ‬2 ‫ ﺑﻪ‬f2 ‫ ﺑﻴﺘﻲ‬8 ‫ ﭘﻴﻜﺴﻞ‬16 ‫ ﻓﺸﺮدهﺳﺎزي ﻣﻲﻛﻨﺪ‬4:1 ‫ﺑﺎ ﻋﺎﻣﻞ‬
>> hcode = h3f2.code;
>> whos('hcode')
Name Size Bytes Class
hcode 1×2 4 uint16 array
Grand total is 2 elements using 4 bytes

>> dec2bin(double(hcode))
ans =
1010101101011011
0000011110011000

(‫ ﺻﻔﺮ آﺧﺮ‬3 ‫ ﻣﺪوﻟﻲ آﺧﺮ )ﻳﻌﻨﻲ‬16 ‫ ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮﻧﺪ و از ﺑﻴﺘﻬﺎي‬h3f2 ‫ ﺑﺮاي ﻧﻤﺎﻳﺶ ﻫﺮ ﻳﻚ از ﺑﻴﺘﻬﺎي‬dec2bin ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ‬

.‫ ﺗﻮﻟﻴﺪ ﻛﺮدﻳﻢ‬6.2.1 ‫ ﺑﻴﺖ ﻓﻮري ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد اﺳﺖ ﻛﻪ ﻗﺒﻼً در ﺑﺨﺶ‬29 ‫ ﺑﻴﺖ ﻣﻌﺎدل ﺑﻠﻮﻛﻬﺎي‬32 ‫ رﻣﺰﮔﺬاري‬.‫ﺻﺮف ﻧﻈﺮ ﻣﻲﺷﻮد‬

‫ ﺣﺎوي اﻃﻼﻋﺎت ﻻزم ﺑﺮاي رﻣﺰﮔﺸﺎﻳﻲ آراﻳﻪ رﻣﺰﮔﺬاري ﺷﺪه )ﻣﺜﻼً اﺣﺘﻤﺎﻻت ﻧﻤﺎدﻫﺎ و‬mat2huff ‫ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﻣﺜﺎل ﻗﺒﻞ ﮔﻔﺘﻴﻢ ﺗﺎﺑﻊ‬

‫ اﻃﻼﻋﺎت اﻳﻦ ﺳﺎﺧﺘﺎر در ﻣﻄﺎﻟﺐ راﻫﻨﻤﺎي ﺑﺨﺶ‬.‫ ﻗﺮار دارﻧﺪ‬MATLAB ‫اﺑﻌﺎد اﺻﻠﻲ( اﺳﺖ ﻛﻪ در ﻳﻜﻲ از ﻣﺘﻐﻴﺮﻫﺎي ﺗﻜﻲ ﻧﺮم اﻓﺰار‬

.‫ درج ﺷﺪه اﺳﺖ‬mat2huff

function y=mat2huff(x)
%MAT2HUFF Huffman encodes a matrix.
% Y = MAT2HUFF(X) Huffman encodes matrix X using symbol
% probabilities in unit-with histogram bins between X's minimum
% and maximum values. The encoded data is returned as a structure
% Y:
% Y.code The Huffman-encoded values of X, stored in
% a uint16 vector. The other fields of Y contain
% additional decoding information, including:
% Y.min The minimum values of X plus 32768
% Y.size The size of X
% Y.hist The histogram of X
%
% If X is logical, uint8, uint16, unit32, int8, int16, or double,
% with integer values, it can be input directly to MAT2HUFF. The
% minimum value of X must be represent able as an int16.
%
% If X is double with non-integer values---for example, and image
% with values between 0 and 1---first scale X to an appropriate
% integer range before the call. For example, use Y =
% MAT2HUFF(255*X) for 256 gray level encoding.
%
% NOTE: The number of Huffman code words is round(max(X(:))) –
% round(min(X(:))) + 1. You may need to scale input X to generate
% codes of reasonable length. The maximum row or column dimension
% of X is 65535.
%
% See also HUFF2MAT.

If ndims(x) ~= 2 | ~isreal(x) | (~isnumeric(x) & ~islogical(x))

error('X must be a 2-D real numeric or logical matrix.');
end

17
% Store the size of input x.
y.size = unit32(size(x));

% Find the range of x values and store its minimum value biased
% by +32768 as a UINT16.
x = round(double(x));
xmin = min(x(:));
xmax = max(x(:));
pmin = double(int16(xmin));
pmin = uint16(pmin + 32768); y.min = pmin;

% Compute the input histogram between xmin and xmax with unit
% width bins, scale to UINT16, and store.
x = x(:)';
h = histc(x, xmin:xmax);
if max(h) > 65535
h = 65535 * h / max(h);
end

% Code the input matrix and store the result.

Map = huffman(double(h));
hx = map(x(:) – xmin + 1);
hx = char(hx)';
hx = hx(:)';
hx(hx == ' ') = [ ];
ysize = ceil(length(hx) / 16);
hx16 = repmat('0', 1, ysize * 16);
hx16(1:length(hx)) = hx;
hx16 = reshape(hx16, 16, ysize);
hx16 = hx16' – '0';
twos = pow2(15:-1:0);
y.code = uint16(sum(hx16 .* twos(ones(ysize, 1), :), 2))';
% Make Huffman code map
% Map image
% Convert to char array
% Remove blanks
% Compute encoded size
% Pre-allocate module-16 vector
% Make hx module-16 in length
% Reshape to 16-character words
% Convert binary string to decimal

‫ را ﺑﺎ اﺳﺘﻔﺎده از ﻣﺤﻔﻈﻪﻫﺎي ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎ ﺑﻪ ﭘﻬﻨﺎي واﺣﺪ ﺑﻴﻦ ﻣﻘﺎدﻳﺮ‬x ‫ ﻫﺎﻓﻤﻦ ﻣﺎﺗﺮﻳﺲ‬y=mat2huff (x) ‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﻋﺒﺎرت‬

‫ ﺑﻌﺪاً رﻣﺰﮔﺸﺎﻳﻲ ﻣﻲﺷﻮﻧﺪ ﻛﺪ ﻫﺎﻓﻤﻦ ﻣﻮرد ﻧﻴﺎز ﺑﺮاي رﻣﺰﮔﺸﺎﻳﻲ‬y‫ وﻗﺘﻲ دادهﻫﺎي رﻣﺰﮔﺬاري ﺷﺪه در‬.‫ رﻣﺰﮔﺬاري ﻣﻲﻛﻨﺪ‬x ‫ﺣﺪاﻗﻞ و ﺣﺪاﻛﺜﺮ‬

‫ ﺑﻪ ﺟﺎي ﺣﻔﻆ رﻣﺰ ﻫﺎﻓﻤﻦ‬Mat2huff .‫ اﺳﺖ ﺳﺎﺧﺘﻪ ﺷﻮد‬x ‫ ﻛﻪ ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎي‬y.hist ‫ اﺳﺖ و‬x‫ ﻛﻪ ﺣﺪاﻗﻞ ﻣﻘﺪار‬y.min ‫آن ﺑﺎﻳﺪ دوﺑﺎره از‬

‫ ذﺧﻴﺮه ﻣﻲﺷﻮد ﺗﺎﺑﻊ‬y.size ‫ ﻛﻪ در‬x ‫ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ اﻳﻦ ﻣﻮﺿﻮع و اﺑﻌﺎد اﺻﻠﻲ ﻣﺎﺗﺮﻳﺲ‬.‫اﻃﻼﻋﺎت ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ﺗﻮﻟﻴﺪ ﻣﺠﺪد آن را ﻧﮕﻪ ﻣﻲدارد‬

.‫ ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮد‬x ‫ و ﺑﺎزﺳﺎزي‬y.code ‫ )ﺑﺨﺶ ﺑﻌﺪ( ﺑﺮاي رﻣﺰﮔﺸﺎﻳﻲ‬.6.2.3 ‫ ﺑﺨﺶ‬huff2mat

:‫ ﺑﻪ ﻃﻮر ﺧﻼﺻﻪ در اﻳﻨﺠﺎ ﺑﻴﺎن ﺷﺪه اﺳﺖ‬y.code ‫ﻣﺮاﺣﻞ ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ﺗﻮﻟﻴﺪ‬

‫ ﺑﺎ اﺳﺘﻔﺎده از ﻣﺤﻔﻈﻪﻫﺎﻳﻲ ﺑﻪ ﭘﻬﻨﺎي واﺣﺪ ﻣﺤﺎﺳﺒﻪ ﻛﻨﻴﺪ و‬x ‫ ﺑﻴﻦ ﺣﺪاﻗﻞ و ﺣﺪاﻛﺜﺮ ﻣﻘﺎدﻳﺮ‬x ‫ را ﺑﺎ دادهﻫﺎي ورودي‬h ‫ اﺑﺘﺪا ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎي‬.1

.‫ ﺟﺎ ﺷﻮد‬uint16 ‫ﻣﻘﻴﺎس آن را ﻃﻮري ﺗﻌﻴﻴﻦ ﻛﻨﻴﺪ ﻛﻪ در ﺑﺮدار‬

.‫ ﻣﻘﻴﺎس ﺑﻨﺪي ﺷﺪه اﺳﺖ‬h ‫ اﺳﺘﻔﺎده ﻛﻨﻴﺪ ﻛﻪ در اﻳﻨﺠﺎ ﻧﻘﺸﻪاي ﻣﺒﺘﻨﻲ ﺑﺮ ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎي‬Huffman ‫ ﺑﺮاي اﻳﺠﺎد رﻣﺰ ﻫﺎﻓﻤﻦ از‬.2

18
‫‪ .3‬دادهﻫﺎي ورودي ‪ x‬را ﺑﺎ اﺳﺘﻔﺎده از ﻧﻘﺸﻪ ﺗﺮﺳﻴﻢ ﻛﻨﻴﺪ )ﺗﺎ ﻳﻚ آراﻳﻪ ﺳﻠﻮﻟﻲ اﻳﺠﺎد ﺷﻮد( و ﺳﭙﺲ آن را ﺑﻪ آراﻳﻪ ﻧﻮﻳﺴﻪاي ‪ hx‬ﺗﺒﺪﻳﻞ ﻛﻨﻴﺪ‪.‬‬

‫ﻓﻀﺎﻫﺎي ﺧﺎﻟﻲ درج ﺷﺪه ﻫﻤﭽﻮن ‪ h2f2‬در ﻣﺜﺎل ‪ 6.2‬را ﺑﺮﻃﺮف ﻛﻨﻴﺪ‪.‬‬

‫‪ .4‬ﺑﺮدار ‪ hx‬را ﻃﻮري درﺳﺖ ﻛﻨﻴﺪ ﻛﻪ ﻧﻮﻳﺴﻪﻫﺎي آن ﺑﻪ ﺻﻮرت ﻗﻄﻌﺎت ‪ 16‬واﺣﺪي در آﻳﺪ‪ .‬اﻳﻦ ﻛﺎر ﺑﺎ اﻳﺠﺎد ﻳﻚ ﺑﺮدار ﻧﻮﻳﺴﻪ ‪ 16‬ﻣﺪوﻟﻲ اﻧﺠﺎم‬

‫ﻣﻲﺷﻮد ﻛﻪ ‪ hx16‬را در رﻣﺰ ﻧﮕﻪ ﻣﻲدارد و ﻋﻨﺎﺻﺮ ‪ hx‬را ﺑﻪ آن ﻛﭙﻲ ﻣﻲﻛﻨﺪ‪ ،‬و آن را در ردﻳﻔﻬﺎي ‪ 16‬واﺣﺪي در آراﻳﻪ ‪ ysize‬ﺷﻜﻞدﻫﻲ‬

‫ﻣﻲﻛﻨﺪ‪ .‬از ﺑﺨﺶ ‪ 4.2‬ﺑﻪ ﺧﺎﻃﺮ دارﻳﻢ ﻛﻪ ﺗﺎﺑﻊ ‪ ceil‬اﻋﺪاد را ﺑﻪ ﺳﻤﺖ ﻣﺜﺒﺖ ﺑﻴﻨﻬﺎﻳﺖ ﮔﺮد ﻣﻲﻛﻨﺪ‪ .‬ﺗﺎﺑﻊ ﻛﻠﻲ ﻧﺮم اﻓﺰار ‪ MATLAB‬ﺑﻪ ﺷﺮح‬

‫زﻳﺮ اﺳﺖ‪:‬‬
‫)‪y = reshape(x, m, n‬‬

‫در اﻳﻨﺠﺎ ‪ m‬از ﻣﺎﺗﺮﻳﺲ ‪ n‬ﺗﻮﻟﻴﺪ ﻣﻲﺷﻮد ﻛﻪ ﻋﻨﺎﺻﺮ آن ﺑﻪ ﺻﻮرت ﺳﺘﻮﻧﻲ از ‪ x‬ﮔﺮﻓﺘﻪ ﻣﻲﺷﻮﻧﺪ‪ .‬اﮔﺮ اﻳﻜﺲ ﺗﻌﺪاد ‪ m*n‬ﻋﺪد ﻋﻨﺼﺮ ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ‬

‫ﺧﻄﺎﻳﻲ ﺗﻮﻟﻴﺪ ﻣﻲﺷﻮد‪.‬‬

‫‪ .5‬ﻋﻨﺎﺻﺮ ‪ 16‬ﻧﻮﻳﺴﻪاي ‪ hx16‬را ﺑﻪ اﻋﺪاد دودوﻳﻲ ‪ 16‬ﺑﻴﺘﻲ ﺗﺒﺪﻳﻞ ﻛﻨﻴﺪ )ﻳﻌﻨﻲ ‪ .(uint16s‬اﻳﻦ ‪ 3‬ﻋﺒﺎرت در راﺑﻄﻪ ﻓﺸﺮده زﻳﺮ ﺟﺎﻳﮕﺰﻳﻦ‬

‫ﻣﻲﺷﻮﻧﺪ‪ .y=uint16 :‬آﻧﻬﺎ ﻫﺴﺘﻪ اﺻﻠﻲ ‪ bin2dec‬ﻫﺴﺘﻨﺪ‪ .‬ﻛﻪ ﻣﻌﺎدل اﻋﺸﺎري رﺷﺘﻪ دودوﻳﻲ را ﺗﻮﻟﻴﺪ ﻣﻲﻛﻨﺪ وﻟﻲ ﺳﺮﻳﻌﺘﺮ ﻫﺴﺘﻨﺪ زﻳﺮا‬

‫ﺟﻨﺒﻪﻫﺎي ﻋﻤﻮﻣﻲ آﻧﻬﺎ ﻛﺎﻫﺶ ﻳﺎﻓﺘﻪ اﺳﺖ‪ .‬ﺗﺎﺑﻊ ‪ pow2y‬ﻣﻄﻠﺐ ﺑﺮاي ﺗﻮﻟﻴﺪ اراﻳﻪاي ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮد ﻛﻪ ﻋﻨﺎﺻﺮ آن ‪ 2‬ﺑﻪ ﺗﻮان ‪ y‬ﻫﺴﺘﻨﺪ‪.‬‬

‫ﻳﻌﻨﻲ ‪ twos= pow2‬آراﻳﻪ ‪ 32768‬را ﺗﻮﻟﻴﺪ ﻣﻲﻛﻨﺪ‪.‬‬

‫ﻣﺜﺎل ‪:6.3‬ﺑﺮاي ﺗﺸﺮﻳﺢ ﺑﻴﺸﺘﺮ ﻋﻤﻠﻜﺮد ﻓﺸﺮدهﺳﺎزي روش رﻣﺰﮔﺬاري ﻫﺎﻓﻤﻦ ﻳﻚ ﺗﺼﻮﻳﺮ ﺗﻚ رﻧﮓ ‪ 8‬ﺑﻴﺘﻲ ‪ 512*512‬را در ﻋﻜﺲ ‪(a).6.4‬ﻧﻈﺮ‬

‫ﺑﮕﻴﺮﻳﺪ‪ .‬ﻓﺸﺮدهﺳﺎزي اﻳﻦ ﺗﺼﻮﻳﺮ ﺑﺎ اﺳﺘﻔﺎده از ‪ mat2huff‬ﺑﺎ اﺟﺮاي دﺳﺘﻮرات زﻳﺮ روي ﺧﻂ ﻓﺮﻣﺎن ﺗﺤﻘﻖ ﻣﻲﻳﺎﺑﺪ‪.‬‬
‫;)'‪>> f = imread('Tracy.tif‬‬
‫;)‪>> c = mat2huff(f‬‬
‫)‪>> cr1 = imratio(f, c‬‬
‫=‪cr1‬‬
‫‪1.219‬‬

‫ﺗﺼﻮﻳﺮ ‪ :6.4‬ﻳﻚ ﺗﺼﻮﻳﺮ ‪ 8‬ﺑﻴﺘﻲ ‪ 512*512‬ﺗﻚ رﻧﮓ از ﻳﻚ زن و ﺑﺰرﮔﻨﻤﺎﻳﻲ ﭼﺸﻢ راﺳﺖ او‬

‫‪19‬‬
‫ﺑﺎ ﺣﺬف ﻛﺮدن دادهﻫﺎي اﺿﺎﻓﻲ ﻣﻮﺟﻮد در رﻣﺰﮔﺬاري دودوﻳﻲ ‪ 8‬ﺑﻴﺘﻲ ﻣﺘﻌﺎرف ﺗﺼﻮﻳﺮ ﺑﻪ ‪ %80‬اﻧﺪازه اﺻﻠﻲ ﺧﻮدش )ﺣﺘﻲ ﺑﺎ اﺣﺘﺴﺎب اﻃﻼﻋﺎت‬

‫ﻋﻤﻮﻣﻲ رﻣﺰﮔﺸﺎﻳﻲ( ﻓﺸﺮده ﻣﻲﺷﻮد‪.‬‬

‫از آﻧﺠﺎﺋﻲ ﻛﻪ دادهﻫﺎي ﺧﺮوﺟﻲ ‪ mat2huff‬ﻳﻚ ﺳﺎزه ﻫﺴﺘﻨﺪ آﻧﻬﺎ را ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ ‪ save‬روي دﻳﺴﻚ ذﺧﻴﺮه ﻣﻲﻛﻨﻴﻢ‪:‬‬
‫;‪>> save SqueezeTracy c‬‬
‫)'‪>> cr2 = imratio('Tracy.tif', 'SqueezeTracy.mat‬‬
‫= ‪cr2‬‬
‫‪1.2365‬‬

‫ﺗﺎﺑﻊ ‪ save‬ﺑﺮاي ذﺧﻴﺮه ﺳﺎزي ﭘﺮوﻧﺪه ﺑﺎ ﺳﺎﻳﺮ ﭘﺴﻮﻧﺪﻫﺎ اﺳﺖ و در اﻳﻦ ﻣﻮرد ﭘﺮوﻧﺪه اﻳﺠﺎد ﺷﺪه را ﺑﺎ ﭘﺴﻮﻧﺪ ‪ .mat‬ذﺧﻴﺮه ﻣﻲﻛﻨﺪ‪ .‬در اﻳﻨﺠﺎ‬

‫ﭘﺮوﻧﺪه ﺣﺎﺻﻞ از آن ﺑﻪ ﻧﺎم ‪ SqueezeTracy.mat‬ﻳﻚ ﭘﺮوﻧﺪه از ﻧﺮم اﻓﺰار ‪ MATLAB‬ﻧﺎﻣﻴﺪه ﻣﻲﺷﻮد‪ .‬اﻳﻦ ﭘﺮوﻧﺪه ﺣﺎوي دادهﻫﺎي‬

‫دودوﻳﻲ و اﺳﺎﻣﻲ ﻣﺘﻐﻴﺮﻫﺎ و ﻣﻘﺎدﻳﺮ ﻣﺤﻴﻂ ﻛﺎر اﺳﺖ‪ .‬ﻫﻤﭽﻨﻴﻦ ﻣﺘﻐﻴﺮ اﻧﻔﺮادي ‪ c‬را ﻧﻴﺰ دارد‪ .‬ﻋﻠﺖ اﺧﺘﻼف اﻧﺪك ﻧﺴﺒﺖ ﻓﺸﺮدهﺳﺎزي ‪cr1, cr2‬‬

‫ﻛﻪ در ﺑﺨﺶ ﻗﺒﻞ ﻣﺤﺎﺳﺒﻪ ﻛﺮدﻳﻢ دادهﻫﺎي ﻣﺘﻔﺮﻗﻪ ﭘﺮوﻧﺪه ﻧﺮم اﻓﺰار ‪ MATLAB‬اﺳﺖ‪.‬‬

‫‪ .1.2.3‬رﻣﺰﮔﺸﺎﻳﻲ ﻫﺎﻓﻤﻦ ) ‪(Huffman Decoding‬‬

‫ﺗﺼﻮﻳﺮﻫﺎي رﻣﺰﮔﺬاري ﺷﺪه ﻫﺎﻓﻤﻦ ﻛﺎرﺑﺮد اﻧﺪﻛﻲ دارﻧﺪ ﻣﮕﺮ آن ﻛﻪ ﺑﺘﻮان آﻧﻬﺎ را دوﺑﺎره ﺑﻪ ﺻﻮرت ﺗﺼﺎوﻳﺮ اﺻﻠﻲ رﻣﺰﮔﺸﺎﻳﻲ ﻛﺮد‪ .‬اﮔﺮ‬

‫‪ y=mat2huff x‬در دادهﻫﺎي ﺧﺮوﺟﻲ ﺑﺨﺶ ﻗﺒﻞ ﺑﺎﺷﺪ‪ ،‬اﺑﺘﺪا رﻣﺰﮔﺸﺎ ﺑﺎﻳﺪ رﻣﺰي را ﻛﻪ در ﻫﺎﻓﻤﻦ ﺑﺮاي رﻣﺰﮔﺸﺎﻳﻲ ‪ x‬ﺑﻪ ﻛﺎر ﻣﻲرود ﺑﺎز ﻛﻨﺪ‬

‫)ﻛﻪ اﻳﻦ ﻛﺎر ﺑﺮ اﺳﺎس ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎ ) ‪ ( histogram‬و اﻃﻼﻋﺎت اﻳﻜﺲ اﻧﺠﺎم ﻣﻲﺷﻮد( و ﺳﭙﺲ دادهﻫﺎي رﻣﺰﮔﺬاري ﺷﺪه را ﺑﻪ ﺻﻮرت ﻣﻌﻜﻮس‬

‫ﺗﺮﺳﻴﻢ ﻛﻨﺪ )ﻛﻪ آﻧﻬﺎ ﺑﺮاي ﺑﺎزﺳﺎزي ‪ x‬از ‪ y‬اﺳﺘﺨﺮاج ﻣﻲﺷﻮﻧﺪ(‪ .‬ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﻓﻬﺮﺳﺖ ﺗﺎﺑﻌﻬﺎي )‪ x=huff2mat(y‬دﻳﺪه ﻣﻲﺷﻮد‪ ،‬اﻳﻦ‬

‫ﻓﺮاﻳﻨﺪ را ﻣﻲﺗﻮان ﺑﻪ ‪ 5‬ﻣﺮﺣﻠﻪ اﺳﺎﺳﻲ ﺗﺠﺰﻳﻪ ﻛﺮد‪:‬‬

‫‪ .1‬اﺳﺘﺨﺮاج اﺑﻌﺎد ‪ m, n‬و ﺣﺪاﻗﻞ ﻣﻘﺪار ‪) xmin‬دادهﻫﺎي ﺧﺮوﺟﻲ ‪ (x‬از ﺳﺎزه دادهﻫﺎي ورودي ‪y‬‬

‫‪ .2‬ﺑﺮاي ﺑﺎزﺳﺎزي رﻣﺰ ﻫﺎﻓﻤﻨﻲ ﻛﻪ ﺑﺮاي رﻣﺰﮔﺬاري ‪ x‬ﺑﻪ ﻛﺎر رﻓﺘﻪ اﺳﺖ ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎي آن را ﺑﻪ ﺗﺎﺑﻊ ﻫﺎﻓﻤﻦ ﺑﺪﻫﻴﺪ‪ .‬رﻣﺰ ﺗﻮﻟﻴﺪ ﺷﺪه در ﻓﻬﺮﺳﺖ‬

‫ﺑﻪ ﻧﺎم ‪ map‬ﻇﺎﻫﺮ ﻣﻲﺷﻮد‪.‬‬

‫‪ .3‬ﺳﺎﺧﺘﺎر اﻃﻼﻋﺎﺗﻲ ﺟﺪوﻟﻬﺎي دادهﻫﺎ و اﻧﺘﻘﺎل را اﻳﺠﺎد ﻛﻨﻴﺪ ﺗﺎ ﺑﺎ ﻳﻚ ﺳﺮي ﺟﺴﺘﺠﻮﻫﺎي دودوﻳﻲ ﻛﺎرآﻣﺪ راﻳﺎﻧﻪاي رﻣﺰﮔﺸﺎﻳﻲ دادهﻫﺎي‬

‫رﻣﺰﮔﺬاري ﺷﺪه در ‪ y.code‬ﺗﺴﺮﻳﻊ ﺷﻮد‪.‬‬

‫‪ .4‬دادهﻫﺎي رﻣﺰﮔﺬاري ﺷﺪه و ﺳﺎﺧﺘﺎر ﻣﺮﺑﻮﻃﻪ را ﺑﻪ ﺗﺎﺑﻊ ‪ c‬ﺑﻪ ﻧﺎم ‪ unravel‬ﻣﻨﺘﻘﻞ ﻛﻨﻴﺪ‪ .‬اﻳﻦ ﺗﺎﺑﻊ زﻣﺎن ﻣﻮرد ﻧﻴﺎز ﺑﺮاي اﺟﺮاي ﺟﺴﺘﺠﻮﻫﺎي‬

‫دودوﻳﻲ را ﻛﻤﻴﻨﻪ ﻣﻲﻛﻨﺪ و ﺑﺮدار رﻣﺰﮔﺸﺎﻳﻲ ﺷﺪه دادهﻫﺎي ‪ x‬را ﻛﻪ از ﻧﻮع ‪ double‬ﻳﺎ ﻣﻀﺎﻋﻒ اﺳﺖ اﻳﺠﺎد ﻣﻲﻛﻨﺪ‪.‬‬

‫‪ xmin .5‬را ﺑﻪ ﻫﺮ ﻋﻨﺼﺮ اﻳﻜﺲ اﺿﺎﻓﻪ ﻛﻨﻴﺪ و ﺷﻜﻞ آن را ﺗﻐﻴﻴﺮ دﻫﻴﺪ ﺗﺎ ﻣﻄﺎﺑﻖ ﺑﺎ اﺑﻌﺎد ‪ x‬اﺻﻠﻲ ﺷﻮد )ﻳﻌﻨﻲ ‪ m‬ﻋﺪد ردﻳﻒ و ‪ n‬ﻋﺪد ﺳﺘﻮن(‬

‫‪20‬‬
‫ ﻣﺮاﺟﻌﻪ‬4 ‫ اﺳﺖ )ﺑﻪ ﻣﺮﺣﻠﻪ‬unravel ‫ ﺑﻪ ﻧﺎم‬MATLAB ‫ ﻧﺮم اﻓﺰار‬c ‫ ادﻏﺎم ﻳﻜﻲ از ﺗﺎﺑﻌﻬﺎي‬huff2mat ‫ﻳﻜﻲ از ﺧﺼﻮﺻﻴﺎت ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد‬

.‫ﻛﻨﻴﺪ( ﻛﻪ ﺑﺎﻋﺚ ﻣﻲﺷﻮد رﻣﺰﮔﺸﺎﻳﻲ ﺗﺼﻮﻳﺮﻫﺎﻳﻲ ﺑﺎ ﺗﻔﻜﻴﻚ ﭘﺬﻳﺮي ﻋﺎدي ﻓﻮري اﻧﺠﺎم ﺷﻮد‬
function x= huff2mat(y)
%HUFF2MAT decodes a Huffman encoded matrix.
% X = H UFF2MAT(Y) decodes a Huffman encoded structure Y with uint16
% fields:
% Y.min Minimum values of X plus 32768
% Y.size Size of X
% Y.hist Histogram of X
% Y.code Huffman code
%
% The output X is of class double.
%
% See also MAT2HUFF.

If –isstruct(y) | ~isfield(y, 'min') | ~isfield(y, 'size') | …

~isfield(y, 'hist') | ~isfield(y, 'code')
error('The input must be a structure as returned by MAT2HUFF.');
end

sz = double(y.size); m = sz(1); n = sz(2);

xmin = double(y.min) – 32768; % Get X minimum
map = huffman(double(y.hist)); % Get Huffman code (cell)

% Create a binary search table for the Huffman decoding process.

% 'code' contains source symbol strings corresponding to 'link'
% nodes, while 'link' contains the address (+) to node pairs for
% node symbol strings plus '0' and '1' or addresses (-) to decoded
% Huffman codewords in 'map'. Array 'left' is a list of nodes yet to
% be processed for 'link' entries.

code = cellstr(char('', '0', '1')); % Set starting conditions as

link = [2; 0; 0]; left = [2 3] % 3 nodes w/2 unprocessed
found = 0; tofind = length(map); % Tracking variables

while length(left) & (found < tofind)

look = find(strcmp(map, code{left(1)})); % Is string in map?
if look % Yes
link(left(1)) = -look; % Point to Huffman map
left = left(2:end); % Delete codes found
found = found + 1; % Increment codes found
else % No, add 2 nodes & pointers
len = length(code); % Put pointers in node
link(left(1)) = len + 1;

link = [link; 0; 0]; % Add unprocessed nodes

code{end + 1} = stract(code{ left(1)}, '0');
code{end + 1} = stract(code{ left(1)}, '1');

left = left(2:end); % Remove processed nodes

left = [left len + 1 len + 2]; % Add 2 unprocessed nodes
end
end
x = unravel(y.code', link, m * n); % Decode using C 'unravel'
x = x + xmin – 1; % X minimum offset adjust
x = reshape(x, m, n); % Make vector an array

21
‫ﻫﻤﺎن ﻃﻮر ﻛﻪ ﻗﺒﻼً ﮔﻔﺘﻴﻢ‪ ،‬رﻣﺰﮔﺸﺎﻳﻲ ﺑﺮ اﺳﺎس ‪ huff2mat‬ﻣﺒﺘﻨﻲ ﺑﺮ ﺟﺴﺘﺠﻮﻫﺎي دودوﻳﻲ و ﻳﺎ ﺗﺼﻤﻴﻢ ﺑﻪ رﻣﺰﮔﺸﺎﻳﻲ ﺑﺮ اﺳﺎس ﻧﺘﺎﻳﺞ دوﮔﺎﻧﻪ‬

‫اﺳﺖ‪.‬‬

‫ﻫﺮ ﻋﻨﺼﺮ از رﺷﺘﻪ رﻣﺰﮔﺬاري ﺷﺪه ﻫﺎﻓﻤﻦ ﻛﻪ ﺑﻪ ﺗﺮﺗﻴﺐ ﺑﺮرﺳﻲ ﻣﻲﺷﻮد ﻛﻪ اﻟﺒﺘﻪ ﺑﺎﻳﺪ ‪ 0‬ﻳﺎ ‪ 1‬ﺑﺎﺷﺪ ﺑﺎﻋﺚ راه اﻧﺪازي روﻧﺪ رﻣﺰﮔﺸﺎﻳﻲ دودوﻳﻲ‬

‫ﺑﺮ اﺳﺎس ﺟﺪول دادهﻫﺎي ﺧﺮوﺟﻲ و اﻧﺘﻘﺎل ﻣﻲﺷﻮد‪ .‬ﻫﺮ ﻳﻚ از ﻋﻨﺎﺻﺮ اراﻳﻪ ‪ link‬ﺳﻪ ﺣﺎﻟﺘﻪ ﻣﻄﺎﺑﻖ ﺑﺎ رﺷﺘﻪﻫﺎي دودوﻳﻲ رﻣﺰﮔﺬاري ﺷﺪه‬

‫ﻫﺎﻓﻤﻦ در آراﻳﻪ ﺳﻠﻮﻟﻲ ﻣﻄﺎﺑﻖ ﺑﺎ آﻧﻬﺎ ﻫﺴﺘﻨﺪ‪ .‬در اﺑﺘﺪا ))’‪ code=cellstr(char(‘’,’0’, ‘1‬اﺳﺖ رﺷﺘﻪ ﺗﻬﻲ ﻛﺪ )‪ (1‬ﻧﻘﻄﻪ ﻣﺒﺪاء )و ﻳﺎ‬

‫ﺣﺎﻟﺖ رﻣﺰﮔﺸﺎﻳﻲ ﻣﻘﺪﻣﺎﺗﻲ( اﺳﺖ ﻛﻪ در ﻫﻤﻪ رﻣﺰﮔﺸﺎﻳﻴﻬﺎي رﺷﺘﻪ ﻫﺎﻓﻤﻦ ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮد‪ .‬ﻋﺪد ‪ 2‬در ﭘﻴﻮﻧﺪ )‪،(1‬دو ﺣﺎﻟﺖ رﻣﺰﮔﺸﺎي‬

‫ﻣﺤﺘﻤﻞ را ﺷﻨﺎﺳﺎﻳﻲ ﻣﻲﻛﻨﺪ ﻛﻪ ‪ 0‬ﻳﺎ ‪ 1‬را ﺑﻪ رﺷﺘﻪ ﺗﻬﻲ ﻣﺘﺼﻞ ﻣﻲﻛﻨﻨﺪ‪ .‬اﮔﺮ ﺑﻴﺖ رﻣﺰﮔﺬاري ﺷﺪه ﺑﻌﺪي ﻫﺎﻓﻤﻦ ﺻﻔﺮ ﺑﺎﺷﺪ‪ ،‬ﺣﺎﻟﺖ رﻣﺰﮔﺸﺎي‬

‫ﺑﻌﺪ )‪ link(2‬اﺳﺖ )از آﻧﺠﺎﺋﻲ ﻛﻪ ‪ code(2)=0‬اﺳﺖ رﺷﺘﻪ ﺗﻬﻲ ﺑﺎ ﺻﻔﺮ ارﺗﺒﺎط دارد(‪ .‬اﮔﺮ ‪ 1‬ﺑﺎﺷﺪ ﺣﺎﻟﺖ ﺟﺪﻳﺪ )‪ link(3‬ﻣﻲﺷﻮد‪ .‬ﺗﻮﺟﻪ‬

‫داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ وروديﻫﺎي آراﻳﻪ ﭘﻴﻮﻧﺪ ﺻﻔﺮ ﻫﺴﺘﻨﺪ ﻳﻌﻨﻲ ﻃﻮري ﭘﺮدازش ﻧﺸﺪهاﻧﺪ ﻛﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ ﺗﺼﻤﻴﻢ ﮔﻴﺮي ﺻﺤﻴﺢ در ﺗﺮﺳﻴﻢ رﻣﺰ ﻫﺎﻓﻤﻦ‬

‫ﺑﺎﺷﻨﺪ‪ .‬در ﺣﻴﻦ ﺳﺎﺧﺖ اﻳﻦ ﭘﻴﻮﻧﺪ اﮔﺮ ﻫﺮ ﻳﻚ از رﺷﺘﻪﻫﺎي ‪ 0‬ﻳﺎ ‪ 1‬در ﻧﻘﺸﻪ ﻳﺎﻓﺖ ﺷﻮد‪) ،‬ﻳﻌﻨﻲ ﻳﻚ رﻣﺰ ﻣﻌﺘﺒﺮ ﻫﺎﻓﻤﻦ ﺑﺎﺷﺪ( ﺻﻔﺮ ﻣﻨﻄﺒﻖ ﺑﺎ آن‬

‫در ﭘﻴﻮﻧﺪ ﺟﺎﻳﮕﺰﻳﻦ ﻣﻘﺪار ﻣﻨﻔﻲ ﺷﺎﺧﺺ ﻧﻘﺸﻪ ﻣﻄﺎﺑﻖ ﺑﺎ آن ﻣﻲﺷﻮد )ﻛﻪ ﻫﻤﺎن ﻣﻘﺪار رﻣﺰﮔﺸﺎﻳﻲ ﺷﺪه اﺳﺖ(‪ .‬در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﻳﻚ ﭘﻴﻮﻧﺪ‬

‫ﺟﺪﻳﺪ ﺑﺎ ﻣﻘﺪار ﻣﺜﺒﺖ درج ﻣﻲﺷﻮد ﺗﺎ اﺷﺎره ﺑﻪ ‪ 2‬ﺣﺎﻟﺖ ﺟﺪﻳﺪ داﺷﺘﻪ ﺑﺎﺷﺪ‪) .‬ﻛﻪ اﻳﻨﻬﺎ رﻣﺰﻫﺎي ﻣﺤﺘﻤﻞ ﻫﺎﻓﻤﻦ ﻫﺴﺘﻨﺪ( ﻛﻪ ﻣﻨﻄﻘﺎٌ ﻳﺎ ﺑﺮ اﺳﺎس‬

‫‪ 00‬و ‪ 01‬ﻫﺴﺘﻨﺪ و ﻳﺎ ‪ 10‬و ‪.11‬‬

‫اﻳﻦ ﻋﻨﺎﺻﺮ ﭘﻴﻮﻧﺪي ﭘﺮدازش ﻧﺸﺪه ﺟﺪﻳﺪ ‪ link‬را اﻓﺰاﻳﺶ ﻣﻲدﻫﻨﺪ )رﻣﺰ آراﻳﻪ ﺳﻠﻮل ﻧﻴﺰ ﺑﺎﻳﺪ ‪ update‬ﺷﻮد( ﻓﺮاﻳﻨﺪ ﺳﺎﺧﺖ آﻧﻘﺪر اداﻣﻪ ﻣﻲﺑﺎد‬

‫ﻛﻪ دﻳﮕﺮ ﻫﻴﭻ ﻋﻨﺼﺮ ﭘﺮدازش ﻧﺸﺪهاي در ‪ link‬ﺑﺎﻗﻲ ﻧﻤﺎﻧﺪ‪ .‬ﺑﻪ ﺟﺎي ﺑﺮرﺳﻲ ﻣﺴﺘﻤﺮ ﻋﻨﺎﺻﺮ ﭘﺮدازش ﻧﺸﺪه در اﻳﻦ ﭘﻴﻮﻧﺪ ‪ huff2mat‬ﻳﻚ اراﻳﻪ‬

‫ردﻳﺎﺑﻲ ﺑﻪ ﻧﺎم ‪ left‬دارد ﻛﻪ ﺑﺎ ‪2‬و ‪ 3‬راه اﻧﺪازي ﻣﻲﺷﻮد و ﺑﻪ ﻫﻨﮕﺎم ﺳﺎزي) ‪ (update‬ﻣﻲﺷﻮد ﺗﺎ ﺷﺎﺧﺼﻬﺎي ﻋﻨﺎﺻﺮ ﭘﻴﻮﻧﺪي ﺑﺮرﺳﻲ ﻧﺸﺪه را‬

‫ﻧﻴﺰ در ﺑﺮ ﺑﮕﻴﺮد‪.‬‬

‫ﺟﺪول ‪ 6.3‬ﺟﺪول اﻳﻦ ﭘﻴﻮﻧﺪ اﺳﺖ ﻛﻪ ﺑﺮاي رﻣﺰ ﻫﺎﻓﻤﻦ در ﻣﺜﺎل ‪ 6.2‬اﻳﺠﺎد ﺷﺪه اﺳﺖ‪ .‬اﮔﺮ ﻫﺮ ﺷﺎﺧﺺ ﭘﻴﻮﻧﺪ ﻳﻚ ﺣﺎﻟﺖ رﻣﺰﮔﺸﺎي ‪ I‬ﻣﺤﺴﻮب‬

‫ﺷﻮد‪ ،‬ﻫﺮ ﻳﻚ از رﻣﺰﮔﺬاريﻫﺎي دودوﻳﻲ )در ﺑﺮرﺳﻲ رﺷﺘﻪ رﻣﺰﮔﺬاري ﺷﺪه از ﭼﭗ ﺑﻪ راﺳﺖ( و ﻳﺎ دادهﻫﺎي ﺧﺮوﺟﻲ رﻣﺰﮔﺸﺎﻳﻲ ﺷﺪه ﻫﺎﻓﻤﻦ ﺑﺎ‬

‫)‪ link(i‬ﻣﺸﺨﺺ ﻣﻲﺷﻮد‪.‬‬

‫‪ .1‬اﮔﺮ ‪ link (i)<0‬ﺑﺎﺷﺪ )ﻳﻌﻨﻲ ﻣﻨﻔﻲ ﺑﺎﺷﺪ( ﻳﻜﻲ از ﻛﻠﻤﺎت رﻣﺰ ﻫﺎﻓﻤﻦ رﻣﺰﮔﺸﺎﻳﻲ ﺷﺪه اﺳﺖ‪ .‬در اﻳﻨﺠﺎ )‪ link(i‬داده ﺧﺮوﺟﻲ رﻣﺰﮔﺸﺎﻳﻲ‬

‫ﺷﺪه اﺳﺖ و ﻗﺪر ﻣﻄﻠﻖ در | | ﻗﻴﺪ ﺷﺪه اﺳﺖ‪.‬‬

‫‪ .2‬اﮔﺮ ‪ link(i) >0‬ﺑﺎﺷﺪ‪) ،‬ﻳﻌﻨﻲ ﻣﺜﺒﺖ ﺑﺎﺷﺪ( و ﺑﻴﺖ رﻣﺰﮔﺬاري ﺷﺪه ﺑﻌﺪي ‪ 0‬ﺑﺎﺷﺪ ﺣﺎﻟﺖ رﻣﺰﮔﺸﺎﻳﻲ ﺑﻌﺪي ﺷﺎﺧﺺ ‪ link i‬اﺳﺖ ﻳﻌﻨﻲ‬

‫ﻓﺮض ﻣﻲﻛﻨﻴﻢ )‪ i = link(i‬اﺳﺖ‪.‬‬

‫‪22‬‬
 ‫‪ .3‬اﮔﺮ ‪ link(i) >0‬ﺑﺎﺷﺪ و ﺑﻴﺖ رﻣﺰي ﺷﺪه ﺑﻌﺪي ‪ 1‬ﺑﺎﺷﺪ ﺣﺎﻟﺖ رﻣﺰﮔﺸﺎﻳﻲ ﺑﻌﺪي ﺷﺎﺧﺺ ‪ link(i) +1‬اﺳﺖ ﻳﻌﻨﻲ ‪i = link(i) + 1‬‬

‫ﺟﺪول ‪ :6.3‬ﺟﺪول رﻣﺰﮔﺸﺎﻳﻲ اراﻳﻪ ﺳﻠﻮﻟﻲ ﻛﺎﻫﺶ ﻣﻨﺒﻊ در ﺗﺼﻮﻳﺮ ‪6.3‬‬

‫ﻫﻤﺎن ﻃﻮر ﻛﻪ ﻗﺒﻼً ﮔﻔﺘﻴﻢ وروديﻫﺎي ﭘﻴﻮﻧﺪﻫﺎي ﻣﺜﺒﺖ ﻣﻄﺎﺑﻖ ﺑﺎ رﻣﺰﮔﺸﺎﻳﻲﻫﺎي اﻧﺘﻘﺎﻟﻲ دودوﻳﻲ ﻫﺴﺘﻨﺪ در ﺣﺎﻟﻲ ﻛﻪ وروديﻫﺎي ﻣﻨﻔﻲ‬

‫ﻣﻘﺎدﻳﺮ رﻣﺰﮔﺸﺎﻳﻲ ﺷﺪه دادهﻫﺎي ﺧﺮوﺟﻲ را ﺗﻌﻴﻴﻦ ﻣﻲﻛﻨﻨﺪ‪ .‬ﺑﻌﺪ از رﻣﺰﮔﺸﺎﻳﻲ ﻫﺮ ﻳﻚ از ﻛﺪﻫﺎي ﻫﺎﻓﻤﻦ ﻳﻚ ﺟﺴﺘﺠﻮي دودوﻳﻲ در ﺷﺎﺧﺺ‬

‫‪ link‬آﻏﺎز ﻣﻲﺷﻮد ﻛﻪ ﺗﻮاﻟﻲ اﻧﺘﻘﺎل ﺣﺎﻟﺖ ﺣﺎﺻﻞ از آن ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ‪ i=1,3,1,2,5,6,1,…:‬ﺗﻮاﻟﻲ دادهﻫﺎي ﺧﺮوﺟﻲ ﻣﻄﺎﺑﻖ ﺑﺎ آن‬

‫‪ _,|_2|,_,_,_,|_3|,_,_,..‬اﺳﺖ‪ .‬ﺧﻂ ﻓﺎﺻﻠﻪ ﻧﻤﺎﻳﺎﻧﮕﺮ ﻧﺒﻮد دادهﻫﺎي ﺧﺮوﺟﻲ اﺳﺖ‪ .‬دادهﻫﺎي ﺧﺮوﺟﻲ رﻣﺰﮔﺸﺎﻳﻲ ﺷﺪه ‪ 2‬و ‪ 3‬ﭘﻴﻜﺴﻞ اول‬

‫ﺳﺘﻮن اول ﺗﺼﻮﻳﺮ آزﻣﺎﻳﺸﻲ ‪ f2‬در ﻣﺜﺎل ‪ 6.2‬اﺳﺖ‪.‬‬

‫ﺗﺎﺑﻊ ‪ unravel‬زﺑﺎن ‪ C‬ﺳﺎزه ﻓﻮق را ﻗﺒﻮل ﻣﻲﻛﻨﺪ و از آن ﺑﺮاي ﺟﺴﺘﺠﻮي دودوﻳﻲ ﺑﺮاي رﻣﺰﮔﺸﺎﻳﻲ دادهﻫﺎي ورودي ‪ hx‬اﺳﺘﻔﺎده ﻣﻲﻛﻨﺪ‪.‬‬

‫ﻋﻤﻠﻜﺮد اﺳﺎﺳﻲ آن در ﻧﻤﻮدار ‪ 6.5‬ﺗﺮﺳﻴﻢ ﺷﺪه اﺳﺖ ﻛﻪ ﻣﻄﺎﺑﻖ ﺑﺎ ﻓﺮاﻳﻨﺪ ﺗﺼﻤﻴﻢ ﮔﻴﺮي ﺗﺸﺮﻳﺢ ﺷﺪه در ﺟﺪول ‪ 6.3‬اﺳﺖ‪ .‬ﺗﻐﻴﻴﺮاﺗﻲ اﻧﺠﺎم ﺷﺪه‬

‫اﺳﺖ ﺗﺎ ﺷﺎﺧﺺ ﺑﻨﺪي آراﻳﻪﻫﺎي ‪ C‬از ﺻﻔﺮ ﺑﻪ ﺟﺎي ﻳﻚ ﺟﺒﺮان ﺷﻮد‪.‬‬

‫ﻣﻲﺗﻮان ﺗﺎﺑﻌﻬﺎي زﺑﺎن ‪ C‬و ‪ Fortran‬را در ﻧﺮم اﻓﺰار ‪ Matlab‬ادﻏﺎم ﻛﺮد ﺗﺎ ﺑﻪ دو ﻫﺪف دﺳﺖ ﻳﺎﻓﺖ‪:‬‬

‫)‪ (1‬ﻣﻲﺗﻮان ﺑﺮﻧﺎﻣﻪﻫﺎي ‪ Fortran‬و ‪ C‬را ﺑﺪون ﻧﻴﺎز ﺑﻪ ﺑﺎزﻧﻮﻳﺴﻲ آﻧﻬﺎ ﺑﻪ ﺻﻮرت ﭘﺮوﻧﺪهﻫﺎي ‪ M‬از ﻧﺮم اﻓﺰار ‪ MATLAB‬ﻓﺮاﺧﻮاﻧﻲ ﻛﺮد‪.‬‬

‫)‪ (2‬آﻧﻬﺎ ﺑﺎﻋﺚ ﺗﺴﺮﻳﻊ ﻣﺤﺎﺳﺒﻪ ﺑﺮﺧﻲ ﭘﺮوﻧﺪهﻫﺎي ‪ M‬ﻧﺮم اﻓﺰار ‪ MATLAB‬ﻣﻲﺷﻮﻧﺪ ﻛﻪ ﻣﻌﻤﻮﻻً ﺑﺎ ﺳﺮﻋﺖ ﻛﺎﻓﻲ اﻧﺠﺎم ﻧﻤﻲﺷﻮﻧﺪ وﻟﻲ‬

‫ﻣﻲﺗﻮان ﺑﺮاي اﻓﺰاﻳﺶ ﻛﺎرآﻳﻲ آﻧﻬﺎ را در‪ C‬ﻳﺎ ‪ Fortran‬رﻣﺰﮔﺬاري ﻛﺮد‪ .‬ﺻﺮف ﻧﻈﺮ از اﺳﺘﻔﺎده از ‪ C‬ﻳﺎ ‪ Fortran‬ﺗﺎﺑﻊﻫﺎي ﺣﺎﺻﻞ از آن را‬

‫ﭘﺮوﻧﺪهﻫﺎي ‪ MEX‬ﻣﻲﻧﺎﻣﻴﻢ‪ .‬رﻓﺘﺎر آﻧﻬﺎ ﻃﻮري اﺳﺖ ﻛﻪ ﮔﻮﻳﻲ ﭘﺮوﻧﺪهﻫﺎي ‪ M‬ﻳﺎ ﺗﺎﺑﻌﻬﺎي ﻋﺎدي ﻧﺮم اﻓﺰار ‪ MATLAB‬ﻫﺴﺘﻨﺪ‪ .‬وﻟﻲ ﺑﺮ‬

‫ﺧﻼف ﭘﺮوﻧﺪهﻫﺎي ‪ M‬آﻧﻬﺎ را ﺑﺎﻳﺪ ﻗﺒﻞ از ﻓﺮاﺧﻮاﻧﻲ ﺑﺎ اﺳﺘﻔﺎده از ﭘﺮوﻧﺪه آﻏﺎزﮔﺮ ‪ MEX‬در ﻧﺮم اﻓﺰار ‪ MATLAB‬ﺗﺪوﻳﻦ و ﻣﺮﺗﺒﻂ ﻛﺮد‪ .‬ﻣﺜﻼً‬

‫ﺑﺮاي ﺗﺒﺪﻳﻞ و ﭘﻴﻮﻧﺪ ﺗﺎﺑﻊ ‪ unravel‬در ﻣﺤﻴﻂ وﻳﻨﺪوز ﻋﺒﺎرت زﻳﺮ در ﺧﻂ ﻓﺮﻣﺎن ﻧﺮم اﻓﺰار‪ Matlab‬ﺑﺎﻳﺪ ﻧﻮﺷﺘﻪ ﺷﻮد‪:‬‬

‫‪23‬‬
>> mex unravel.c

‫ ﺟﺪاﮔﺎﻧﻪ ﺑﺎ ﻫﻤﺎن‬M ‫ ﻫﺮ ﻧﻮع ﻣﺘﻦ راﻫﻨﻤﺎ ﺑﻪ ﺻﻮرت ﻳﻚ ﭘﺮوﻧﺪه‬.‫ اﻳﺠﺎد ﻣﻲﺷﻮد‬dll ‫ ﺑﺎ ﭘﺴﻮﻧﺪ‬unravel.dll ‫ ﺑﻪ ﻧﺎم‬MEX ‫ﺳﭙﺲ ﻳﻚ ﭘﺮوﻧﺪه‬

.‫ اﻳﺠﺎد ﻣﻲﺷﻮد‬.m ‫ﻧﺎم و ﭘﺴﻮﻧﺪ‬

:‫ دارد و ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ‬.c ‫ ﭘﺴﻮﻧﺪ‬unravel ‫ﺑﻪ ﻧﺎم‬C MEX ‫ﻛﺪ ﻣﻨﺒﻊ ﭘﺮوﻧﺪه‬

Unravel.c
‫ ﺑﻴﺘﻲ اﺳﺖ( و روﻧﺪ ﻣﺮﺗﺐ ﺳﺎزي آن دودوﻳﻲ‬16 ‫ﻛﻪ ﻳﻚ رﺷﺘﻪ ﺑﻪ ﻃﻮل ﻣﺘﻐﻴﺮ رﻣﺰﮔﺬاري ﺷﺪه را رﻣﺰﮔﺸﺎﻳﻲ ﻣﻲﻛﻨﺪ )و ﺑﺮداري ﺑﺎ اﻋﺪاد ﺻﺤﻴﺢ‬

.‫ اﺳﺖ ﻛﻪ ﺑﺮ اﺳﺎس ﺟﺪول اﻧﺘﻘﺎل اﻧﺠﺎم ﻣﻲﺷﻮد‬lsb ‫ ﺑﻪ‬msb ‫از‬

/*===============================================
* unravel.c
* Decodes a variable length coded bit sequence (a vector of
* 16-bit integers) using a binary sort from the MSB to the LSB
* (across word boundaries) based on a transition table.
*===============================================
#include "mex.h"
void unravel(unsigned short *hx, double *link, double *x,
double xsz, int hxsz)
{
int I = 15, j = 0, k = 0, n = 0; /* Start ar root node, 1st */
/* hx bit and x element */
while (xsz – k) { /* Do until x is filled */
if (*(link + n) > 0) { /* Is there a link? */
if ((*hx + j) >> j) & 0x0001) /* Is bit a 1? */
n = *(link + n); /* Yes, get new node */
else n = *(link + n) – 1; /* It's 0 so get new node */
if (i) i--; else {j++; i = 15;} /* Set i, j to next bit */
if (j > hxsz) /* Bits left to decode? */
mexErrMsgTxt("Out of code bits ???");
}
else { /* It must be a leaf node */
* (x + k++) = -*(link + n); /* Output value */
n = 0; } /* Start over at root */
}
if (k == xsz – 1) /* Is one left over? */
* (x + k++) = -*(link + n);
}
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
double *link, *x, xsz;
usigned short *hx;
int hxsz;

/* Check inputs for reasonableness */

if (nrhs != 3)
mexErrMsgTxt("Three inputs required.");
else if (nlhs > 1)
mexErrMsgTxt("Too output argument.");

24
/* Is last input argument a scalar? */
if (!mxIsDouble(prhs[2]) || mxIsComplex(prhs[2]) ||
mxGetN(prhs[2]) * mxGetM(prhs[2]) != 1)
mexErrMsgTxt("Input XSIZE must be a scalar.");
/* Create input matrix pointers and get scalar */
hx = mxGetPr(prhs[0]); /* UINT16 */
link = mxGetPr(prhs[1]); /* DOUBLE */
xsz = mxGetScalat(prhs[2]); /* DOUBLE */

/* Get the number of elements in hx */

hxsz = mxGetM(prhs[0]);

/* Create 'xsz' x 1 output matrix */

plhs[0] = mxCreateDoubleMatrix(xsz, 1, mxREAL);

/* Get C pointer to a copy of the output matrix */

x = mxGetpr(plhs[0]);

/* Call the C subroutine */

unravel(hx, link, x, xsz, hxsz);
}

.‫ اﻳﺠﺎد ﻣﻲﺷﻮد‬unravel.m ‫ ﺑﻪ ﻧﺎم‬M ‫ﻣﺘﻦ راﻫﻨﻤﺎ در ﭘﺮوﻧﺪه‬

%UNRAVEL Decodes a variable-length bit stream.
% X = UNRAVEL(Y, LINK, XLEN) decodes UINT16 input vector Y based on
% transition and output table LINK. The elements of Y are
% considered to be a contiguous stream of encoded bits--i.e., the
% MSB of one element follows the LSB of the previous element. Input
% XLEN is the number of code words in Y, and thus the size of output
% vector X (class DOUBLE). Input LINK is a transition and output
% table (that drives a series of binary searches):
%
% 1. LINK(0) is the entry point for decoding, i.e., state n = 0.
% 2. If LINK(n) < 0, the decoded output is | LINK(n)|; set n = 0.
% 3. If LINK(n) > 0, get the next encoded bit and transition to
% state [LINK(n) – 1] if the bit is 0, else LINK(n).

‫ از دو ﺑﺨﺶ ﻣﺘﻤﺎﻳﺰ ﺗﺸﻜﻴﻞ ﺷﺪه اﺳﺖ ﻛﻪ آﻧﻬﺎ را روال ﻣﺤﺎﺳﺒﺎﺗﻲ و‬C MEX ‫ ﻫﻤﭽﻮن ﺳﺎﻳﺮ ﭘﺮوﻧﺪهﻫﺎي‬unravel.c ٫C MEX ‫ﭘﺮوﻧﺪه‬

.‫دروازه ﻣﻲﻧﺎﻣﻴﻢ‬

.‫ را اﺟﺮا ﻣﻲﻛﻨﺪ‬6.5 ‫ اﺳﺖ ﻛﻪ ﻓﺮاﻳﻨﺪ رﻣﺰﮔﺸﺎﻳﻲ ﺗﺼﻮﻳﺮ‬C ‫روال ﻣﺤﺎﺳﺒﺎﺗﻲ ﻛﻪ آن را روال ﮔﺮهﮔﺸﺎ ﻧﻴﺰ ﻣﻲﻧﺎﻣﻴﻢ ﺣﺎوي رﻣﺰ‬

‫ ارﺗﺒﺎط‬huff2mat ‫ ﻓﺮاﺧﻮان ﺗﺎﺑﻊ‬M ‫ و ﭘﺮوﻧﺪه‬c ‫ در‬unravel ‫ اﺳﺖ ﻛﻪ ﺑﻴﻦ روال ﻣﺤﺎﺳﺒﺎﺗﻲ‬MexFunction ‫ﻧﺎم ﻫﻤﻴﺸﮕﻲ روال دروازه‬

‫اﻳﺠﺎد ﻣﻲﻛﻨﺪ‬

:‫ اﺳﺘﻔﺎده ﻣﻲﻛﻨﺪ ﻛﻪ ﺑﺮ اﺳﺎس ﻣﻮارد زﻳﺮ اﺳﺖ‬MATLAB ‫ ﻧﺮم اﻓﺰار‬Mex ‫از ﻣﻴﺎﻧﺠﻲ اﺳﺘﺎﻧﺪارد ﭘﺮوﻧﺪه‬

25
 ‫‪ .1‬ﭼﻬﺎر ﭘﺎراﻣﺘﺮ اﺳﺘﺎﻧﺪارد از دادهﻫﺎي ورودي و ﺧﺮوﺟﻲ‪:‬‬

‫اﻳﻦ ﭘﺎراﻣﺘﺮﻫﺎ ﺷﻤﺎره ﺷﻨﺎﺳﻪﻫﺎي ﺳﻤﺖ ﭼﭗ دادهﻫﺎي ﺧﺮوﺟﻲ )ﻋﺪد ﺻﺤﻴﺢ(‪ ،‬و آراﻳﻪاي از اﺷﺎرهﮔﺮﻫﺎي ﺳﻤﺖ ﭼﭗ ﺷﻨﺎﺳﻪﻫﺎي دادهﻫﺎي‬

‫ﺧﺮوﺟﻲ )ﻛﻪ ﻫﻤﮕﻲ آراﻳﻪﻫﺎي ﻧﺮم اﻓﺰار ‪ MATLAB‬ﻫﺴﺘﻨﺪ( ﻣﻲﺑﺎﺷﻨﺪ‪ .‬ﺗﻌﺪاد ﺷﻨﺎﺳﻪﻫﺎي دادهﻫﺎي ورودي ﺳﻤﺖ راﺳﺖ )ﻳﻚ ﻋﺪد ﺻﺤﻴﺢ‬

‫دﻳﮕﺮ(‪ ،‬و آراﻳﻪ اﺷﺎرهﮔﺮﻫﺎي ﺷﻨﺎﺳﻪﻫﺎي دادهﻫﺎي ورودي ﺳﻤﺖ راﺳﺖ )ﻫﻤﮕﻲ آراﻳﻪﻫﺎي ﻧﺮم اﻓﺰار ‪ MATLAB‬ﻫﺴﺘﻨﺪ(‬

‫‪ .2‬ﻣﺠﻤﻮﻋﻪاي از ﺗﺎﺑﻌﻬﺎي ﻣﻴﺎﻧﺠﻲ ﺑﺮﻧﺎﻣﻪﻫﺎي ﻛﺎرﺑﺮدي ﻛﻪ در ﻧﺮم اﻓﺰار ‪ Matlab‬ﺗﻬﻴﻪ ﺷﺪه اﺳﺖ‪ .‬اﻳﻦ ﺗﺎﺑﻌﻬﺎ ﻛﻪ ﭘﺴﻮﻧﺪ ‪ mx‬دارﻧﺪ ﺑﺮاي اﻳﺠﺎد‪،‬‬

‫دﺳﺘﺮﺳﻲ ﺑﻪ‪ ،‬ﻣﺪﻳﺮﻳﺖ‪ ،‬و ﻳﺎ ﺗﺨﺮﻳﺐ ﺳﺎﺧﺘﺎر آراﻳﻪﻫﺎي ﻧﻮع ‪ mx‬ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮﻧﺪ‪ .‬ﻣﺜﻼً‬

‫‪ mxCalloc‬دادهﻫﺎي ﺣﺎﻓﻈﻪ را ﻫﻤﭽﻮن ﻳﻚ ﺗﺎﺑﻊ اﺳﺘﺎﻧﺪارد ‪ C Calloc‬ﺑﻪ ﺷﻜﻞ ﭘﻮﻳﺎ ﺗﺨﺼﻴﺺ ﻣﻲدﻫﺪ‪ .‬ﺗﺎﺑﻌﻬﺎي ﻣﺮﺗﺒﻂ ‪mxMalloc,‬‬

‫‪ mxRealloc‬ﻫﺴﺘﻨﺪ ﻛﻪ ﺑﻪ ﺟﺎي ﺗﺎﺑﻌﻬﺎي ‪ Cmalloc, realloc‬ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮﻧﺪ‪.‬‬

‫‪ mxGetScalar‬ﻛﻤﻴﺖ ﻋﺪدي را از دادهﻫﺎي ورودي آراﻳﻪ ‪ prhs‬اﺳﺘﺨﺮاج ﻣﻲﻛﻨﺪ‪ .‬ﺳﺎﻳﺮ ﺗﺎﺑﻌﻬﺎي ‪ mxGet‬ﻣﺎﻧﻨﺪ ‪mxGetM, mxGetn,‬‬

‫‪ mxGetString‬ﺳﺎﻳﺮ اﻧﻮاع داده را اﺳﺘﺨﺮاج ﻣﻲﻛﻨﻨﺪ‪.‬‬

‫‪ MATLAB‬ﺑﺮاي ‪ plhs‬اﻳﺠﺎد ﻣﻲﻛﻨﺪ‪ .‬ﺳﺎﻳﺮ ﺗﺎﺑﻌﻬﺎي ‪ MxCreate‬ﻣﺎﻧﻨﺪ‬ ‫‪ mxCreateDoubleMatrix‬ﻳﻚ آراﻳﻪ‬

‫‪ mxCreateString, mxCreateNumericArray‬اﻳﺠﺎد ﺳﺎﻳﺮ اﻧﻮاع دادهﻫﺎي را ﺗﺴﻬﻴﻞ ﻣﻲﻛﻨﻨﺪ‪.‬‬

‫ﺗﺎﺑﻌﻬﺎي ﻣﻴﺎﻧﺠﻲ ﺑﺎ ﭘﺴﻮﻧﺪ ‪ mex‬ﻋﻤﻠﻴﺎﺗﻲ را در ﻣﺤﻴﻂ ﻧﺮم اﻓﺰار ‪ MATLAB‬اﻧﺠﺎم ﻣﻲدﻫﻨﺪ‪ .‬ﻣﺜﻼً ‪ mexErrMsgTxt‬ﻳﻚ ﭘﻴﺎم را در‬

‫ﻣﺤﻴﻂ ﻛﺎر ﻧﺮم اﻓﺰار ‪ MATLAB‬ﻗﺮار ﻣﻲدﻫﺪ‪.‬‬

‫ﻛﻪ در ﺑﺨﺶ ‪ 2‬ﻓﻬﺮﺳﺖ ﻗﺒﻞ ﺑﻪ آﻧﻬﺎ اﺷﺎره ﺷﺪ در ﭘﺮوﻧﺪهﻫﺎي ﺳﺮﻧﻮﻳﺲ ﻧﺮم اﻓﺰار ‪ MATLAB‬ﺑﺎ‬ ‫ﺗﺎﺑﻌﻬﺎي اﺻﻠﻲ ﻣﻴﺎﻧﺠﻲ ‪mx٫ mex‬‬

‫اﺳﺎﻣﻲ ‪ mex.h, matrix.h‬ﻫﺴﺘﻨﺪ‪ .‬ﻫﺮ دو در ﻣﺴﻴﺮ ﺑﻴﺮوﻧﻲ ﻧﺼﺐ ﻧﺮم اﻓﺰار ‪ MATLAB‬ﻫﺴﺘﻨﺪ‪ <matlab> .‬رﻳﺸﻪ دراﻳﻮي اﺳﺖ ﻛﻪ ﻧﺮم‬

‫اﻓﺰار ‪ MATLAB‬روي آن ﻧﺼﺐ ﻣﻲﺷﻮد‪.‬‬

‫ﺳﺮﻧﻮﻳﺲ ‪ mex.h‬ﺑﺎﻳﺪ در آﻏﺎز ﻫﻤﻪ ﭘﺮوﻧﺪهﻫﺎي ‪ mex‬درج ﺷﻮد‪) .‬ﺑﻪ ﻋﺒﺎرت درج ﭘﺮوﻧﺪه ‪ #include “mex.h” c‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ﻛﻪ داراي‬

‫ﭘﺮوﻧﺪه ﺳﺮﻧﻮﻳﺲ ‪ metrix.h‬اﺳﺖ‪.‬‬

‫ﻧﻤﻮﻧﻪﻫﺎي اﺻﻠﻲ رواﻟﻬﺎي ﻣﻴﺎﻧﺠﻲ ‪ mex, mx‬ﻛﻪ در اﻳﻦ ﭘﺮوﻧﺪهﻫﺎ درج ﺷﺪه اﺳﺖ ﭘﺎراﻣﺘﺮﻫﺎي ﻣﻮرد اﺳﺘﻔﺎده را ﺗﻌﺮﻳﻒ ﻣﻲﻛﻨﻨﺪ و ﻧﺸﺎﻧﻪﻫﺎي‬

‫ارزﺷﻤﻨﺪ ي درﺑﺎره ﻋﻤﻠﻴﺎت ﻛﻠﻲ آﻧﻬﺎ دارﻧﺪ‪ .‬ﺳﺎﻳﺮ اﻃﻼﻋﺎت دردﻓﺘﺮﭼﻪ راﻫﻨﻤﺎي ﻣﻴﺎﻧﺠﻲﻫﺎي ﺑﻴﺮوﻧﻲ ﻧﺮم اﻓﺰار ‪MATLAB )MATLAB‬‬

‫‪ (External Interfaces Refrences‬ﻗﻴﺪ ﺷﺪه اﺳﺖ‪.‬‬

‫ﺑﺤﺚ ﻗﺒﻞ در ﺗﺼﻮﻳﺮ ‪ 6.6‬ﺧﻼﺻﻪ ﺷﺪه اﺳﺖ و داراي ﺟﺰﺋﻴﺎت ﺳﺎﺧﺘﺎر ﭘﺮوﻧﺪهﻫﺎي ‪ c mex‬اﺳﺖ و ﺟﺮﻳﺎن اﻃﻼﻋﺎت را ﺑﻴﻦ آﻧﻬﺎ و ﭘﺮوﻧﺪه ‪M‬‬

‫‪ huff2mat‬ﻧﺸﺎن ﻣﻲدﻫﺪ‪ .‬ﮔﺮﭼﻪ ﺑﺮ اﺳﺎس رﻣﺰﮔﺸﺎﻳﻲ ﻫﺎﻓﻤﻦ اﻳﺠﺎد ﺷﺪه اﺳﺖ‪ ،‬وﻟﻲ ﻣﻄﺎﻟﺐ آن را ﻣﻲﺗﻮان ﺑﻪ راﺣﺘﻲ ﺑﻪ ﺳﺎﻳﺮ ﺗﺎﺑﻌﻬﺎي‬

‫‪ MATLAB‬و‪ C‬و ‪ Fortran‬ﻧﻴﺰ ﺗﻌﻤﻴﻢ داد‪.‬‬

‫‪26‬‬
 ‫‪.‬‬

‫ﺗﺼﻮﻳﺮ ‪ :6.6‬ﻛﻨﺶ و واﻛﻨﺶ ﭘﺮوﻧﺪه ‪ mhuff2mat‬و ﺗﺎﺑﻊ ‪ unravel‬ﻓﺮاﺧﻮانﭘﺬﻳﺮ در ﻧﺮم اﻓﺰار ‪ MATLAB‬ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ‪c‬‬

‫‪ 2 mex file unravel‬ﻛﺎرﺑﺮد دارد‪ :‬ﺑﻪ ﻋﻨﻮان روال دروازه ‪ mex function‬و روال ﻣﺤﺎﺳﺒﺎﺗﻲ ‪ unravel‬ﻣﺘﻦ راﻫﻨﻤﺎ در ﭘﺮوﻧﺪه دﻳﮕﺮي ﺑﻪ‬

‫ﻧﺎم ‪ unravel‬اﺳﺖ‪.‬‬

‫‪27‬‬
 ‫ﺗﺼﻮﻳﺮ رﻣﺰﮔﺬاري ﺷﺪه ﻫﺎﻓﻤﻦ در ﻣﺜﺎل ‪ 6.3‬را ﻣﻲﺗﻮان ﺑﺎ ﺗﻮاﻟﻲ ﻓﺮﻣﺎﻧﻬﺎي زﻳﺮ رﻣﺰﮔﺸﺎﻳﻲ ﻛﺮد‪:‬‬

‫ﻣﺜﺎل ‪ :6.4‬رﻣﺰﮔﺸﺎﻳﻲ ﺑﺎ ‪huff2mat‬‬

‫ﺗﺎﺑﻊ ‪ load file‬ﻣﺘﻐﻴﺮﻫﺎي ‪ MATLAB‬را از ﭘﺮوﻧﺪهﻫﺎ ﻣﻲﺧﻮاﻧﺪ آﻧﻬﺎ را داﺧﻞ ﻣﺤﻴﻂ ﻛﺎر ﺑﺎرﮔﺬاري ﻣﻲﻛﻨﺪ‪ .‬اﺳﺎﻣﻲ ﻣﺘﻐﻴﺮﻫﺎ ﺑﻪ ﺗﺮﺗﻴﺐ‬

‫ذﺧﻴﺮه ﺳﺎزي و ﺑﺎرﮔﺬاري ﺣﻔﻆ ﻣﻲﺷﻮﻧﺪ‪.‬‬

‫;‪>> load SqueezeTracy‬‬
‫;)‪>> g = huff2mat(c‬‬
‫;)'‪>> f = imread('Tracy.tif‬‬
‫)‪>> rmse = compare(f, g‬‬
‫= ‪rmse‬‬
‫‪0‬‬

‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ در اﻳﻦ ﻓﺮاﻳﻨﺪ رﻣﺰﮔﺬاري و رﻣﺰﮔﺸﺎﻳﻲ اﻃﻼﻋﺎت ﺣﻔﻆ ﻣﻲﺷﻮﻧﺪ‪ .‬ﺧﻄﺎي ﺟﺬر ﻣﻴﺎﻧﮕﻴﻦ ﻣﺮﺑﻌﺎت ﺑﻴﻦ ﺗﺼﻮﻳﺮﻫﺎي اﺻﻠﻲ و‬

‫ﻧﺎﻓﺸﺮده ﺷﺪه ﺻﻔﺮ اﺳﺖ‪ .‬از آﻧﺠﺎﺋﻲ ﻛﻪ ﺑﻴﺸﺘﺮ رﻣﺰﮔﺸﺎﻳﻲ در ﭘﺮوﻧﺪهﻫﺎي ‪ c mex‬اﻧﺠﺎم ﻣﻲﺷﻮد ‪ huff2mat‬اﻧﺪﻛﻲ ﺳﺮﻳﻌﺘﺮ از ﻫﻤﺘﺎي رﻣﺰﮔﺬار‬

‫ﺧﻮد اﺳﺖ‪ .‬ﺑﻪ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ ﺑﺎرﮔﻴﺮي)‪ (load function‬ﺑﺮاي ﺑﻪ دﺳﺖ آوردن دادهﻫﺎي ﺧﺮوﺟﻲ رﻣﺰﮔﺬاري ﺷﺪه در ﻣﺜﺎل ‪ 6.3‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ‪.‬‬

‫‪ .6.3‬اﻓﺰوﻧﮕﻲ ﺑﻴﻦ ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي) ‪(Interpixel Redundancy‬‬

‫ﺗﺼﺎوﻳﺮ ‪ (a).6.7‬و)‪ (c‬و ‪ (b)6.7‬و)‪ (d‬ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎﻫﺎي ﻳﻜﺴﺎن دارﻧﺪ‪ .‬اﻳﻦ ﺳﺎﺑﻘﻪ ﻧﻤﺎه)‪(histogram‬ا ﺳﻪ ﺣﺎﻟﺘﻪ ﻫﺴﺘﻨﺪ و ﻣﻘﺎدﻳﺮ ﺳﻄﺢ‬

‫ﺧﺎﻛﺴﺘﺮي ﻋﻤﺪﺗﺎً ﺑﻪ ‪ 3‬ﺷﻜﻞ در آﻧﻬﺎ دﻳﺪه ﻣﻲﺷﻮد‪.‬‬

‫ﺗﺼﻮﻳﺮ ‪ 2 :6.7‬ﺗﺼﻮﻳﺮ و ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎﻫﺎي ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي آﻧﻬﺎ‬

‫‪28‬‬
‫از آﻧﺠﺎﺋﻲ ﻛﻪ ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﺗﺼﺎوﻳﺮ ﺑﺮاﺑﺮ ﻧﻴﺴﺘﻨﺪ‪ ،‬رﻣﺰﮔﺬاري ﺑﺎ ﻃﻮل ﻣﺘﻐﻴﺮ ﺑﺮاي ﻛﺎﻫﺶ اﻓﺰوﻧﮕﻲ رﻣﺰﮔﺬاري ﺑﻪ ﻛﺎر ﻣﻲرود ﻛﻪ رﻳﺸﻪ آن‬

‫رﻣﺰﮔﺬاري ﻃﺒﻴﻌﻲ دودوﻳﻲ ﭘﻴﻜﺴﻠﻬﺎ اﺳﺖ‪.‬‬

‫;)'‪>> f1 = imread('Random Matches.tif‬‬
‫;)‪>> c1 = mat2huff(f1‬‬
‫)‪>> entropy(f1‬‬
‫= ‪ans‬‬
‫‪7.4253‬‬
‫)‪>> imratio(f1, c1‬‬
‫= ‪ans‬‬
‫‪1.0704‬‬
‫;)'‪>> f2 = imread('Aligned Matches.tif‬‬
‫;)‪>> c2 = mat2huff(f2‬‬
‫)‪>> entropy(f2‬‬
‫= ‪ans‬‬
‫‪7.3505‬‬
‫)‪>> imratio(f2, c2‬‬
‫= ‪ans‬‬
‫‪1.0821‬‬

‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ در اﻳﻨﺠﺎ ﺷﺎﺧﺺ درﺟﻪ ﺑﻲﻧﻈﻤﻲ ‪ 2‬ﺗﺼﻮﻳﺮ ﻳﻜﺴﺎن اﺳﺖ و ﺑﺎ ‪ mat2huff‬ﺑﻪ ﻃﻮر ﻳﻜﺴﺎن ﻓﺸﺮدهﺳﺎزي ﺷﺪهاﻧﺪ )ﻧﺴﺒﺖ‬

‫ﻓﺸﺮدهﺳﺎزي ‪ 1.0704‬ﺑﻪ ‪ 1.0821‬اﺳﺖ(‪ .‬ﺑﻨﺎ ﺑﺮ اﻳﻦ رﻣﺰﮔﺬاري ﺑﺎ ﻃﻮل ﻣﺘﻐﻴﺮ ﺑﺮاي اﺳﺘﻔﺎده از رواﺑﻂ ﺳﺎﺧﺘﺎري آﺷﻜﺎر ﺑﻴﻦ ﻣﻮارد ﻫﻤﺮاﺳﺘﺎ در‬

‫ﺗﺼﻮﻳﺮ ‪ (c)6.7‬ﻧﻴﺴﺖ‪ .‬ﮔﺮﭼﻪ ارﺗﺒﺎﻃﻬﺎي ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي در اﻳﻦ ﻋﻜﺲ ﻣﺸﺨﺺ اﺳﺖ وﻟﻲ در ﺗﺼﻮﻳﺮ ‪ (a)6.7‬ﻧﻴﺰ دﻳﺪه ﻣﻲﺷﻮﻧﺪ‪ .‬از آﻧﺠﺎﺋﻲ ﻛﻪ‬

‫ﻣﻘﺎدﻳﺮ ﭘﻴﻜﺴﻠﻬﺎي ﻫﺮ ﺗﺼﻮﻳﺮ را ﻣﻲﺗﻮان از ﻣﻘﺎدﻳﺮ ﻣﺠﺎور آﻧﻬﺎ ﭘﻴﺶ ﺑﻴﻨﻲ ﻛﺮد اﻳﻦ ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي ﺣﺎﻣﻞ اﻃﻼﻋﺎت اﻧﺪﻛﻲ ﻫﺴﺘﻨﺪ‪ .‬اﻳﻦ ﭘﻴﻜﺴﻠﻬﺎ‬

‫ﺑﺮاي ﻧﻤﺎﻳﺶ ﺗﺼﺎوﻳﺮ اﻃﻼﻋﺎت اﺿﺎﻓﻲ ﻧﻴﺰ دارﻧﺪ ﻛﻪ ﻣﻲﺗﻮان آن را ﺑﺮ اﺳﺎس ﻣﻘﺎدﻳﺮ ﻣﺠﺎور ﺣﺪس زد‪ .‬اﻳﻦ رواﺑﻂ ﻣﺒﻨﺎي ﺧﺼﻮﺻﻴﺎت اﺿﺎﻓﻲ‬

‫ﺑﻲﺧﺎﺻﻴﺖ ﭘﻴﻜﺴﻠﻬﺎ ﻫﺴﺘﻨﺪ‪.‬‬

‫ﺑﺮاي ﻛﺎﻫﺶ اﻓﺰوﻧﮕﻲ ﺑﻴﻦ ﭘﻴﻜﺴﻠﻬﺎ اراﻳﻪ ﭘﻴﻜﺴﻞ ‪ 2‬ﺑﻌﺪي ﻛﻪ ﻣﻌﻤﻮﻻً ﺑﺮاي ﻣﺸﺎﻫﺪه ﺑﺎ ﭼﺸﻢ اﺳﺘﻔﺎده ﻣﻲﺷﻮد ﺗﺒﺪﻳﻞ ﺑﻪ ﻗﺎﻟﺒﻲ ﻛﺎرآﻣﺪ ﻣﻲﺷﻮد‬

‫ﻛﻪ ﺟﻨﺒﻪ ﺗﺼﻮﻳﺮي ﻧﺪارد‪ .‬ﻣﺜﻼً اﺧﺘﻼف ﺑﻴﻦ ﻋﻨﺼﺮﻫﺎي ﻣﺠﺎور ﺑﺮاي ﻧﻤﺎﻳﺶ ﺗﺼﻮﻳﺮ ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮﻧﺪ‪ .‬در ﺗﺒﺪﻳﻠﻬﺎﻳﻲ از اﻳﻦ ﻧﻮع )ﻛﻪ اﻓﺰوﻧﮕﻲ‬

‫ﺑﻴﻦ ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي ﺑﺮﻃﺮف ﻣﻲﺷﻮد( ﻧﻘﺸﻪ ﺑﺮداري ﻧﺎﻣﻴﺪه ﻣﻲﺷﻮﻧﺪ‪ .‬اﮔﺮ ﺑﺘﻮان ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮ اﺻﻠﻲ را ﺑﺎ دادهﻫﺎي ﺗﺒﺪﻳﻞ ﺷﺪه ﺑﺎزﺳﺎزي ﻛﺮد‬

‫ﻧﻘﺸﻪ ﺑﺮداري ﺑﺮﮔﺸﺖﭘﺬﻳﺮ ﻧﺎﻣﻴﺪه ﻣﻲﺷﻮﻧﺪ‪.‬‬

‫ﻳﻚ روش ﻧﻘﺸﻪ ﺑﺮداري ﺳﺎده در ﺗﺼﻮﻳﺮ ‪ 6.8‬ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‪ .‬ﻧﺎم اﻳﻦ روش ﭘﻴﺶ ﺑﻴﻨﻲ رﻣﺰﮔﺬاري ﺑﺪون ﺧﺴﺎرت) ‪lossless‬‬

‫‪ (predictive coding‬اﺳﺖ‪ .‬ﺑﺮاي ﺣﺬف اﻓﺰوﻧﮕﻲ ﺑﻴﻦ ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي ﻣﺠﺎور‪ ،‬اﻃﻼﻋﺎت ﺟﺪﻳﺪ ﻫﺮ ﻋﻨﺼﺮ اﺳﺘﺨﺮاج و رﻣﺰﮔﺬاري ﻣﻲﺷﻮد‪.‬‬

‫اﻃﻼﻋﺎت ﺟﺪﻳﺪ ﻫﺮ ﻋﻨﺼﺮ ﺗﺼﻮﻳﺮي ﺗﻔﺎوت ﺑﻴﻦ ﻣﻘﺪار واﻗﻌﻲ و ﭘﻴﺶ ﺑﻴﻨﻲ ﺷﺪه آن ﻋﻨﺼﺮ اﺳﺖ‪ .‬ﻫﻤﺎن ﻃﻮر ﻛﻪ دﻳﺪه ﻣﻲﺷﻮد اﻳﻦ ﺳﻴﺴﺘﻢ از ﻳﻚ‬

‫رﻣﺰﮔﺬار و ﻳﻚ رﻣﺰﮔﺸﺎ ﺗﺸﻜﻴﻞ ﺷﺪه اﺳﺖ‪.‬‬

‫‪29‬‬
‫ﻛﻪ ﻫﺮ ﻛﺪام از آﻧﻬﺎ ﻳﻚ ﭘﻴﺶﺑﻴﻨﻲ ﻛﻨﻨﺪه ﻳﻜﺴﺎن دارد‪ .‬وﻗﺘﻲ ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي ﺑﻪ ﺻﻮرت ﭘﻲدرﭘﻲ ﺑﻪ ﻧﺎم ‪ fn‬ﺑﻪ رﻣﺰﮔﺬار داده ﻣﻲﺷﻮﻧﺪ اﺑﺰار ﭘﻴﺶ‬

‫ﺑﻴﻨﻲ ﻛﻨﻨﺪه ﻣﻘﺪار ﻗﺎﺑﻞ ﭘﻴﺶ ﺑﻴﻨﻲ آن ﻋﻨﺼﺮ ﺗﺼﻮﻳﺮي را ﺑﺮ اﺳﺎس ﻣﻘﺎدﻳﺮ دادهﻫﺎي ورودي ﻗﺒﻠﻲ ﺗﻌﻴﻴﻦ ﻣﻲﻛﻨﺪ‪ .‬ﺳﭙﺲ دادهﻫﺎي ﺧﺮوﺟﻲ‬

‫ﭘﻴﺶﺑﻴﻨﻲ ﻛﻨﻨﺪه ﺑﻪ ﻧﺰدﻳﻜﺘﺮﻳﻦ ﻋﺪد ﺻﺤﻴﺢ ﮔﺮد ﻣﻲﺷﻮﻧﺪ ﺗﺎ ‪ fn‬را ﺗﺸﻜﻴﻞ دﻫﻨﺪ و اﺧﺘﻼف ﻳﺎ ﺧﻄﺎي ﭘﻴﺶﺑﻴﻨﻲ را اﻳﺠﺎد ﻣﻲﻛﻨﻨﺪ‬

‫?‬

‫ﻛﻪ ﺑﺎ اﺳﺘﻔﺎده از رﻣﺰي ﺑﺎ ﻃﻮل ﻣﺘﻐﻴﺮ )ﺑﺎ ﻧﻤﺎد رﻣﺰﮔﺬار( رﻣﺰﮔﺬاري ﻣﻲﺷﻮد ﺗﺎ ﻋﻨﺼﺮ ﺑﻌﺪي ﺟﺮﻳﺎن ﻓﺸﺮده دادهﻫﺎ را ﺗﺸﻜﻴﻞ دﻫﺪ‪ .‬رﻣﺰﮔﺬار‬

‫ﺗﺼﻮﻳﺮ ‪ en , (b)6.8‬را از ﻛﻠﻤﺎت رﻣﺰي درﻳﺎﻓﺖ ﺷﺪه ﺑﺎ ﻃﻮل ﻣﺘﻐﻴﺮ ﺑﺎزﺳﺎزي ﻣﻲﻛﻨﺪ و ﻋﻤﻠﻴﺎت ﻣﻌﻜﻮس را اﻧﺠﺎم ﻣﻲدﻫﺪ‪.‬‬

‫?‬

‫ﻣﻲﺗﻮان ﺑﺮاي ﺗﻮﻟﻴﺪ ˆ‪ fn‬از روﺷﻬﺎي ﺳﺎزﮔﺎر ﮔﻮﻧﺎﮔﻮن ﻣﻮﺿﻌﻲ و ﻛﻠﻲ اﺳﺘﻔﺎده ﻛﺮد‪ .‬اﻳﻦ ﭘﻴﺶﺑﻴﻨﻲﻫﺎ در اﻛﺜﺮ ﻣﻮارد ﺑﺎ ﺗﺮﻛﻴﺐ ﺧﻄﻲ ‪ m‬ﻋﺪد‬

‫ﻋﻨﺼﺮ ﺗﺼﻮﻳﺮي اﻧﺠﺎم ﻣﻲﺷﻮد ﻳﻌﻨﻲ اﻳﻦ ﻛﻪ‬

‫?‬

‫در اﻳﻨﺠﺎ ‪ m‬ﺗﺮﺗﻴﺐ اﺑﺰار ﭘﻴﺶﺑﻴﻨﻲ ﻛﻨﻨﺪه ﺧﻄﻲ اﺳﺖ‪ round .‬ﺗﺎﺑﻌﻲ اﺳﺖ ﻛﻪ ﺑﺮاي ﮔﺮد ﻛﺮدن و رﺳﻴﺪن ﺑﻪ ﻧﺰدﻳﻜﺘﺮﻳﻦ ﻋﺪد ﺻﺤﻴﺢ ﺑﻪ ﻛﺎر‬

‫ﺑﺮده ﻣﻲﺷﻮد )ﻣﺎﻧﻨﺪ ﺗﺎﺑﻊ ﻣﻄﺎﺑﻖ ﺑﺎ آن در ﻧﺮم اﻓﺰار ‪ (Matlab‬و ‪ ai‬در‪ i=1, 2, … ,m‬ﺿﺮاﻳﺐ ﭘﻴﺶﺑﻴﻨﻲﻫﺎ ﻫﺴﺘﻨﺪ‪ .‬اﻳﻦ ﻣﻌﺎدﻟﻪ در رﻣﺰﮔﺬاري‬

‫ﺧﻄﻲ ﺗﻚ ﺑﻌﺪي ﺑﻪ ﺷﻜﻞ زﻳﺮ ﻧﻮﺷﺘﻪ ﻣﻲﺷﻮد‪:‬‬

‫?‬

‫‪30‬‬
‫ﻫﺮ ﻳﻚ از ﻣﺘﻐﻴﺮﻫﺎي زﻳﺮﻧﻮﻳﺲ ﺑﻪ ﺻﻮرت ﺗﺎﺑﻌﻲ از ﻣﺨﺘﺼﺎت ﻓﻀﺎﻳﻲ ‪ x‬و ‪ y‬ﺑﻴﺎن ﻣﻲﺷﻮد‪ .‬ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﺗﺎﺑﻊ )‪ f(x, y‬ﺗﺎﺑﻊ ﻋﻨﺎﺻﺮ‬

‫ﺗﺼﻮﻳﺮي ﻗﺒﻠﻲ در ﺧﻂ ﭘﻴﻤﺎﻳﺶ ﺟﺎري اﺳﺖ‪.‬ﺗﺎﺑﻌﻬﺎي ‪ mat2Lpc, Lpc2mat M‬ﺑﺮاي اﺟﺮاي رﻣﺰﮔﺬاري ﻫﻤﺮاه ﺑﺎ ﭘﻴﺶﺑﻴﻨﻲ و رﻣﺰﮔﺸﺎي‬

‫)ﺑﻪ ﻏﻴﺮ از ﻣﺮاﺣﻞ ﻧﻤﺎدﻳﻦ رﻣﺰﮔﺬاري و رﻣﺰﮔﺸﺎﻳﻲ( ﻫﺴﺘﻨﺪ‪ .‬ﺗﺎﺑﻊ رﻣﺰﮔﺬار ‪ mat2Lpc‬ﺑﺮاي ﭘﻴﺶﺑﻴﻨﻲ ﻫﺮ ﻳﻚ از ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي و ﻗﺮار دادن‬

‫آن در دادهﻫﺎي ورودي ‪ x‬از ﺣﻠﻘﻪ اﺳﺘﻔﺎده ﻣﻲﻛﻨﺪ‪ .‬ﺑﻌﺪ از ﻫﺮ دﻓﻌﻪ ﺗﻜﺮار ‪ xs‬ﻛﻪ ﺑﻪ ﺻﻮرت ﻛﭙﻲ از ط اﺳﺖ ﻳﻚ ﺳﺘﻮن ﺑﻪ ﺳﻤﺖ راﺳﺖ ﻣﻨﺘﻘﻞ‬

‫ﻣﻲﺷﻮد و ﻻﻳﻪﮔﺬاري ﺳﻤﺖ ﭼﭗ ﺻﻔﺮ اﺳﺖ و ﺿﺮﺑﺪر ﻳﻚ ﺿﺮﻳﺐ ﭘﻴﺶﺑﻴﻨﻲ ﻣﻨﺎﺳﺐ ﻣﻲﺷﻮد و ﺑﺎ ﻣﺠﻤﻮع ﭘﻴﺶﺑﻴﻨﻲﻫﺎي ‪ p‬ﺟﻤﻊ ﻣﻲﺷﻮد‪ .‬از‬

‫آﻧﺠﺎﺋﻲ ﻛﻪ ﺗﻌﺪاد ﺿﺮاﻳﺐ ﭘﻴﺶﺑﻴﻨﻲ ﺧﻄﻲ ﻣﻌﻤﻮﻻً اﻧﺪك اﺳﺖ‪ ،‬ﻛﻞ اﻳﻦ ﻓﺮاﻳﻨﺪ ﺳﺮﻳﻊ اﻧﺠﺎم ﻣﻲﺷﻮد‪ .‬در ﻓﻬﺮﺳﺖ زﻳﺮ ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ اﮔﺮ‬

‫ﻓﻴﻠﺘﺮ ﭘﻴﺶﺑﻴﻨﻲ ‪ f‬ﻣﺸﺨﺺ ﻧﺸﻮد از ﻳﻚ ﻓﻴﻠﺘﺮ ﺗﻚ ﻋﻨﺼﺮي ﺑﺎ ﺿﺮﻳﺐ ‪ 1‬اﺳﺘﻔﺎده ﻣﻲﺷﻮد‪.‬‬

‫)‪function y = mat2lpc(x, f‬‬
‫‪%MAT2LPC Compresses a matrix using 1-D lossless predictive coding.‬‬
‫‪%‬‬ ‫‪Y = MAT2LPC(X, F) encodes matrix X using 1-D lossless predictive‬‬
‫‪%‬‬ ‫‪coding. A linear prediction of X is made based on the‬‬
‫‪%‬‬ ‫‪coefficients in F. If F is omitted, F = 1 (for previous pixel‬‬
‫‪%‬‬ ‫‪coding) is assumed. The prediction error is then computed and‬‬
‫‪%‬‬ ‫‪output as encoded matrix Y.‬‬
‫‪%‬‬
‫‪%‬‬ ‫‪See also LPC2MAT.‬‬

‫;))‪error(nargchk(1, 2, nargin‬‬ ‫‪% Check input arguments‬‬

‫‪if nargin < 2‬‬ ‫‪% Set default filter if omitted‬‬
‫;‪f = 1‬‬
‫‪end‬‬

‫;)‪x = double(x‬‬ ‫‪%‬‬ ‫‪Ensure double for computations‬‬

‫;)‪[m, n] = size(x‬‬ ‫‪%‬‬ ‫‪Get dimensions of input matrix‬‬
‫;)‪p = zeros(m, n‬‬ ‫‪%‬‬ ‫‪Init linear prediction to 0‬‬
‫;‪xs = x‬‬ ‫;)‪zc = zeros(m, 1‬‬ ‫‪%‬‬ ‫‪Prepare for input shift and pad‬‬

‫)‪for j = 1:length(f‬‬ ‫…‪% For each filter coefficient‬‬

‫;])‪xs = [zc xs(:, 1:end – 1‬‬ ‫‪% Shift and zero x‬‬
‫;‪p = p + f(j) * xs‬‬ ‫‪% Form partial prediction sums‬‬
‫‪end‬‬
‫;)‪y = x – round(p‬‬ ‫‪% Compute the prediction error‬‬

‫ﺗﺎﺑﻊ رﻣﺰﮔﺸﺎي ‪ Lpc2mat‬ﻋﻤﻠﻴﺎت ﻣﻌﻜﻮس ﻫﻤﺘﺎي رﻣﺰﮔﺬار ﺧﻮد ﺑﺎ ﻧﺎم ‪ mat2lpc‬را اﻧﺠﺎم ﻣﻲدﻫﺪ‪ .‬ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﻓﻬﺮﺳﺖ زﻳﺮ دﻳﺪه‬

‫ﻣﻲﺷﻮد‪ ،‬از ﺣﻠﻘﻪاي ﺑﺎ ‪ n‬ﻋﺪد ﺗﻌﺪاد دﻓﻌﺎت ﺗﻜﺮار اﺳﺘﻔﺎده ﻣﻲﻛﻨﺪ ﻛﻪ در اﻳﻨﺠﺎ ‪ n‬ﺗﻌﺪاد ﺳﺘﻮﻧﻬﺎي ﻣﺎﺗﺮﻳﺲ رﻣﺰﮔﺬاري ﺷﺪه دادهﻫﺎي ورودي ‪y‬‬

‫اﺳﺖ‪ .‬در ﻫﺮ دﻓﻌﻪ ﺗﻜﺮار ﻳﻚ ﺳﺘﻮن از دادهﻫﺎي ﺧﺮوﺟﻲ رﻣﺰﮔﺸﺎﻳﻲ ﺷﺪه ‪ x‬ﻣﺤﺎﺳﺒﻪ ﻣﻲﺷﻮد زﻳﺮا ﻫﺮ ﺳﺘﻮن رﻣﺰﮔﺸﺎﻳﻲ ﺷﺪه ﺑﺮاي ﻣﺤﺎﺳﺒﻪ‬

‫ﻫﻤﻪ ﺳﺘﻮﻧﻬﺎي ﺑﻌﺪي ﺑﻪ ﻛﺎر ﻣﻲرود‪ .‬ﺑﺮاي ﻛﺎﻫﺶ زﻣﺎن ﻣﺼﺮف ﺷﺪه در ﺣﻠﻘﻪ ﻓﻮق ﻗﺒﻞ از ﺷﺮوع ﺣﻠﻘﻪ ﻣﻘﺪار اﻳﻜﺲ ﭘﻴﺸﺎﭘﻴﺶ ﺑﻪ ﺣﺪاﻛﺜﺮ‬

‫ﻻﻳﻪﮔﺬاري ﺗﺨﺼﻴﺺ داده ﻣﻲﺷﻮد‪ .‬ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﻣﺤﺎﺳﺒﺎت ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ﺗﻮﻟﻴﺪ ﭘﻴﺶﺑﻴﻨﻲﻫﺎ ﺑﺎ ﻫﻤﺎن ﺗﺮﺗﻴﺒﻲ ﻛﻪ در ‪Lpc2mat‬‬

‫ﺑﺮاي ﺟﻠﻮﮔﻴﺮي از ﺧﻄﺎي ﮔﺮد ﻛﺮدن ﻧﻘﻄﻪ ﺷﻨﺎور اﻧﺠﺎم ﻣﻲﺷﺪ اﻧﺠﺎم ﻣﻲﺷﻮﻧﺪ‪.‬‬

‫‪31‬‬
function x = lpc2mat(y, f)
%LPC2MAT Decompresses a 1-D lossless predictive encoded matrix.
% X = LPC2MAT(Y, F) decodes input matrix Y based on linear
% prediction coefficients in F and the assumption of 1-D lossless
% predictive coding. If F is omitted, filter F = 1 (for previous
%
% See also MAT2LPC.

error(nargchk(1, 2, nargin)); % Check input arguments

if nargin < 2 % Set default filter if omitted
f = 1;
end

f = f(end:-1:1); % Reverse the filter coefficients

[m, n] = size(y); % Get dimensions of output matrix
order = length(f); % Get order of linear predictor
f = repmat(f, m, 1); % Duplicate filter for vector zing
x = zeros(m, n + order); % pad for 1st 'order' column
decodes
% Decode the output one column at a time. Compute a prediction based
% on the 'order' previous elements and add it to the prediction
% error. The result is appended to the output matrix being built.
for j = 1:n % For each filter coefficient…
jj = j + order;
x(:, jj) = y(:, j) + round(f(:, order:-1:1) .* …
x(:, (jj – 1): -1:(jj – order)), 2));
end
x = x(:, order + 1:end); % Remove left padding
‫ رﻣﺰﮔﺬاري ﺑﺪون اﺗﻼف ﭘﻴﺶﺑﻴﻨﻲ‬:6.5 ‫ﻣﺜﺎل‬

:‫ در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‬1 ‫( ﺑﺎ اﺳﺘﻔﺎده از اﺑﺰار ﭘﻴﺶﺑﻴﻨﻲ ﺧﻄﻲ درﺟﻪ‬c)6.7 ‫رﻣﺰﮔﺬاري ﺗﺼﻮﻳﺮ‬

fˆ ( x, y ) = round [af ( x, y − 1)]

‫ﭘﻴﺶﺑﻴﻨﻲ ﻛﻨﻨﺪهاي از اﻳﻦ ﻧﻮع را ﻋﻤﻠﻴﺎت ﭘﻴﺶﺑﻴﻨﻲ ﻛﻨﻨﺪه ﻋﻨﺎﺻﺮ ﻗﺒﻠﻲ ﻣﻲﻧﺎﻣﻴﻢ و اﻳﻦ ﻧﻮع روش رﻣﺰﮔﺬاري و ﭘﻴﺶﺑﻴﻨﻲ را رﻣﺰﮔﺬاري‬

‫ در اﻳﻨﺠﺎ ﺳﻄﺢ‬.‫( دﻳﺪه ﻣﻲﺷﻮد‬a)6.9 ‫ اﻳﺠﺎد ﺷﺪه اﺳﺖ در ﻋﻜﺲ‬a=1 ‫ ﺗﺼﻮﻳﺮ داراي ﺧﻄﺎي ﭘﻴﺶﺑﻴﻨﻲ ﻛﻪ در ﺣﺎﻟﺖ‬.‫ﺗﻔﺎﺿﻠﻲ ﻣﻲﻧﺎﻣﻴﻢ‬

.‫ ﻣﻄﺎﺑﻖ ﺑﺎ ﺧﻄﺎي ﭘﻴﺶﺑﻴﻨﻲ ﺻﻔﺮ اﺳﺖ‬128 ‫ﺧﺎﻛﺴﺘﺮي‬

‫( ﭘﻴﺸﻴﻨﻪ ﻧﻤﺎي ﺧﻄﺎي ﭘﻴﺶﺑﻴﻨﻲ‬b) 6.7 ‫( ﺗﺼﻮﻳﺮ ﺧﻄﺎي ﭘﻴﺶﺑﻴﻨﻲ ﺗﺼﻮﻳﺮ‬a) :6.9 ‫ﺗﺼﻮﻳﺮ‬

32
 ‫ﺧﻄﺎﻫﺎي ﻣﺜﺒﺖ و ﻣﻨﻔﻲ ﻏﻴﺮﺻﻔﺮ ﺑﻪ ﺗﺮﺗﻴﺐ ﺗﻮﺳﻂ ‪ mat2gray‬ﺳﺎﻳﻪﻫﺎي روﺷﻦ و ﺗﻴﺮه ﺧﺎﻛﺴﺘﺮي ﻣﻲﺷﻮﻧﺪ‪.‬‬
‫;)'‪>> f = imread('Aligned Matches.tif‬‬
‫;)‪>> e = mat2huff(f‬‬
‫;))‪>> imshow(mat2gray(e‬‬
‫)‪>> entropy(e‬‬
‫= ‪ans‬‬
‫‪5.9727‬‬

‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﺷﺎﺧﺺ درﺟﻪ ﺑﻲﻧﻄﻤﻲ ﺧﻄﺎي ﭘﻴﺶﺑﻴﻨﻲ ‪ e‬ﺑﺴﻴﺎر ﻛﻤﺘﺮ از ﻫﻤﻴﻦ ﺷﺎﺧﺺ در ﺗﺼﻮﻳﺮ اﺻﻠﻲ ‪ f‬اﺳﺖ‪ .‬ﻣﻘﺪار اﻳﻦ ﺷﺎﺧﺺ‬

‫از ‪) 7.3505‬ﻛﻪ در اواﻳﻞ اﻳﻦ ﺑﺨﺶ ﻣﺤﺎﺳﺒﻪ ﺷﺪ( ﺑﻪ ‪ 5.9727‬ﺑﻴﺖ در ﻫﺮ ﭘﻴﻜﺴﻞ ﻛﺎﻫﺶ ﻳﺎﻓﺘﻪ اﺳﺖ در ﺻﻮرﺗﻲ ﻛﻪ در ﺗﺼﻮﻳﺮﻫﺎي ‪ m‬ﺑﻴﺘﻲ‬

‫ﺑﺮاي ﻧﻤﺎﻳﺶ دﻗﻴﻖ ﺗﻮاﻟﻲ ﺧﻄﺎي ﺣﺎﺻﻞ از آﻧﻬﺎ ﺑﺎﻳﺪ ‪ m+1‬ﺑﻴﺖ ﻣﻮرد ﻧﻴﺎز اﺳﺖ‪ .‬ﻛﺎﻫﺶ ﺷﺎﺧﺺ درﺟﻪ ﺑﻲﻧﻈﻤﻲ ﻧﺸﺎن ﻣﻲدﻫﺪ ﻛﻪ ﺗﺼﻮﻳﺮ‬

‫ﺧﻄﺎي ﭘﻴﺶﺑﻴﻨﻲ را ﻣﻲﺗﻮان ﻛﺎرآﻣﺪﺗﺮ رﻣﺰﮔﺬاري ﻛﺮد ﺗﺎ ﺗﺼﻮﻳﺮ اﺻﻠﻲ ﻫﺪف ﻧﻘﺸﻪ ﺑﺮداري ﺷﻮد‪ .‬ﺑﻨﺎ ﺑﺮ اﻳﻦ‬
‫;)‪>> c = mat2huff(e‬‬
‫)‪>> cr = imratio(f, c‬‬
‫= ‪cr‬‬
‫‪1.3311‬‬

‫ﻫﻤﺎن ﻃﻮر ﻛﻪ اﻧﺘﻈﺎر ﻣﻲرود ﻣﻲﺑﻴﻨﻴﻢ ﻧﺴﺒﺖ ﻓﺸﺮدهﺳﺎزي از ‪) 1.0821‬وﻗﺘﻲ ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﻣﺴﺘﻘﻴﻤﺎً ﺑﺎ ﻫﺎﻓﻤﻦ رﻣﺰﮔﺬاري ﻣﻲﺷﻮﻧﺪ( ﺑﻪ‬

‫‪ 1.3311‬اﻓﺰاﻳﺶ ﻳﺎﻓﺘﻪ اﺳﺖ‪.‬‬

‫ﺳﺎﺑﻘﻪ ﻧﻤﺎي ﺧﻄﺎي ﭘﻴﺶﺑﻴﻨﻲ ‪ e‬در ﺗﺼﻮﻳﺮ ‪ (b)6.9‬ﻧﺸﺎن داده ﺷﺪه اﺳﺖ و ﻣﺤﺎﺳﺒﻪ آن ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ‪:‬‬
‫;)‪>> [h, x] = hist(e(:) * 512, 512‬‬
‫;)'‪>> figure; bar(x, h, 'k‬‬

‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﻧﺰدﻳﻚ ﺑﻪ ﺻﻔﺮ ﺑﻪ ﻧﻘﻄﻪ اوج ﺧﻮد ﻣﻲرﺳﺪ و در ﻗﻴﺎس ﺑﺎ ﻣﻴﺰان ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﺗﺼﻮﻳﺮﻫﺎي ورودي اﺧﺘﻼف اﻧﺪﻛﻲ‬

‫دارد )ﺗﺼﻮﻳﺮ ‪ .(d 6.7‬در اﻳﻦ ﺣﺎﻟﺖ ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﺷﺎﺧﺼﻬﺎي ﻣﺤﺎﺳﺒﻪ ﺷﺪه درﺟﻪ ﺑﻲﻧﻈﻤﻲ دﻳﺪﻳﻢ در ﻓﺮاﻳﻨﺪﻫﺎي اﻳﺠﺎد اﺧﺘﻼف و‬

‫ﭘﻴﺶﺑﻴﻨﻲ اﻛﺜﺮ اﻓﺰوﻧﮕﻲﻫﺎي ﺑﻴﻦ ﭘﻴﻜﺴﻠﻬﺎ از ﺑﻴﻦ ﻣﻲرود‪ .‬ﺑﺎ ﻧﻤﺎﻳﺶ روش رﻣﺰﮔﺬاري ﺑﺪون اﺗﻼف اﻃﻼﻋﺎت ﻳﻌﻨﻲ ﺑﺎ رﻣﺰﮔﺸﺎﻳﻲ ‪ C‬و ﻣﻘﺎﻳﺴﻪ‬

‫آن ﺑﺎ ﺗﺼﻮﻳﺮ اوﻟﻴﻪ ‪ f‬اﻳﻦ ﻣﺜﺎل را ﺑﻪ ﭘﺎﻳﺎن ﻣﻲرﺳﺎﻧﻴﻢ‪.‬‬

‫;))‪>> g = lpc2mat(huff2mat(c‬‬
‫)‪>> compare(f, g‬‬
‫= ‪ans‬‬
‫‪0‬‬

‫‪33‬‬
 ‫‪ .6.4‬اﻓﺰوﻧﮕﻲ رواﻧﻲ‪ -‬دﻳﺪاري ) ‪(Psychovisual Redundancy‬‬

‫اﻳﻦ ﻧﻮع اﻓﺰوﻧﮕﻲ ﺑﺮ ﺧﻼف رﻣﺰﮔﺸﺎﻳﻲ و اﻓﺰوﻧﮕﻲ ﺑﻴﻦ ﭘﻴﻜﺴﻠﻲ ﺑﺎ اﻃﻼﻋﺎت ﺗﺼﻮﻳﺮي ﺳﻨﺠﺶﭘﺬﻳﺮ واﻗﻌﻲ ﺳﺮ و ﻛﺎر دارد‪ .‬ﺣﺬف آن از آن ﺟﻬﺖ‬

‫ﻣﻄﻠﻮب اﺳﺖ ﻛﻪ اﻳﻦ اﻃﻼﻋﺎت ﺑﺮاي ﭘﺮدازش ﺗﺼﻮﻳﺮي ﻋﺎدي ﺿﺮوري ﻧﻴﺴﺖ‪ .‬از آﻧﺠﺎﺋﻲ ﻛﻪ ﺣﺬف دادهﻫﺎي اﺿﺎﻓﻲ ﻣﺮﺑﻮط ﺑﻪ ﺟﻨﺒﻪ رواﻧﻲ –‬

‫دﻳﺪاري ﺑﺎﻋﺚ از دﺳﺖ دادن اﻃﻼﻋﺎت ﻛﻤﻲ ﻣﻲﺷﻮد آن را ﻛﻤﻲ ﺳﺎزي ﻣﻲﻧﺎﻣﻴﻢ‪ .‬اﻳﻦ ﻛﻠﻤﻪ ﻓﻨﻲ ﺑﺎ ﻛﺎرﺑﺮد اﻳﻦ واژه ﺳﺎزﮔﺎر اﺳﺖ ﻳﻌﻨﻲ ﻧﻘﺸﻪ‬

‫ﺑﺮداري از ﺣﻴﻄﻪ ﮔﺴﺘﺮدهاي از دادهﻫﺎي ورودي ﺑﺮاي اﻳﺠﺎد ﺗﻌﺪاد ﻣﺤﺪودي دادهﻫﺎي ﺧﺮوﺟﻲ‪ .‬از آﻧﺠﺎﺋﻲ ﻛﻪ اﻳﻦ ﻓﺮاﻳﻨﺪ ﺑﺮﮔﺸﺖﻧﺎﭘﺬﻳﺮ اﺳﺖ‬

‫)ﻳﻌﻨﻲ اﻃﻼﻋﺎت دﻳﺪاري از ﺑﻴﻦ ﻣﻲرود( ﻛﻤﻲ ﺳﺎزي ﻣﻌﻤﻮﻻً ﻣﻨﺠﺮ ﺑﻪ ﻓﺸﺮدهﺳﺎزي ﻫﻤﺮاه ﺑﺎ از دﺳﺖ دادن اﻃﻼﻋﺎت ﻣﻲﺷﻮد‪.‬‬

‫ﻣﺜﺎل ‪ :6.6‬ﻓﺸﺮدهﺳﺎزي ﺑﺎ ﻛﻤﻲ ﺳﺎزي‬

‫ﻋﻜﺴﻬﺎي ﺗﺼﻮﻳﺮ ‪ 6.10‬را در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ‪ .‬در ﺗﺼﻮﻳﺮ ‪ (a).6.10‬ﻳﻚ ﻋﻜﺲ ﺗﻚ رﻧﮓ ﺑﺎ ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ‪ 256‬ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‪ .‬ﺗﺼﻮﻳﺮ‬

‫‪ (b)6.10‬ﻫﻤﺎن ﺗﺼﻮﻳﺮ ﺑﻌﺪ از ﻛﻤﻲ ﺳﺎزي ‪ 4‬ﺑﻴﺘﻲ در ‪ 16‬ﺳﻄﺢ ﻣﺤﺘﻤﻞ اﺳﺖ‪ .‬ﻧﺴﺒﺖ ﻓﺸﺮدهﺳﺎزي ‪ 2:1‬اﺳﺖ‪ .‬ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ‬

‫ﻣﺤﺪودهﺳﺎزي ﻛﺎذب در ﻧﻮاﺣﻲ ﻫﻤﻮار ﺗﺼﻮﻳﺮ اﺻﻠﻲ دﻳﺪه ﻣﻲﺷﻮد‪ .‬اﻳﻦ ﺗﺎﺛﻴﺮ ﺗﺼﻮﻳﺮي ﻃﺒﻴﻌﻲ ﻧﻤﺎﻳﺶ ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﺗﺼﻮﻳﺮ اﺳﺖ‪.‬‬

‫در ﺗﺼﻮﻳﺮ ‪ (c)6.10‬ﺑﻬﺒﻮد وﺿﻌﻴﺖ ﺑﺎ ﻛﻤﻲ ﺳﺎزي دﻳﺪه ﻣﻲﺷﻮد ﻛﻪ از ﺧﺼﻮﺻﻴﺎت ﭼﺸﻢ اﻧﺴﺎن ﻫﻨﮕﺎم ﺗﻤﺎﺷﺎي ﺗﺼﻮﻳﺮ ﺑﻬﺮهﺑﺮداري ﺷﺪه اﺳﺖ‪.‬‬

‫ﮔﺮﭼﻪ ﻓﺸﺮدهﺳﺎزي ﺣﺎﺻﻞ از اﻳﻦ ﻧﻮع ﻛﻤﻲ ﺳﺎزي ‪ 2:1‬اﺳﺖ ﺑﺮاي ﻛﺎﻫﺶ ﻣﺤﺪوده ﺳﺎزي ﻛﺎذب دادﻧﻪﻫﺎي ﺑﻴﺸﺘﺮ وﻟﻲ ﻧﻪ ﭼﻨﺪان ﻧﺎراﺣﺖ ﻛﻨﻨﺪه‬

‫ﻛﻨﺪه دﻳﺪه ﻣﻲﺷﻮﻧﺪ‪ .‬ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ در ﻫﺮ ‪ 2‬ﻣﻮرد ﻧﺎﻓﺸﺮدهﺳﺎزي ﻏﻴﺮﺿﺮوري و ﻏﻴﺮﻣﻤﻜﻦ اﺳﺖ‪) .‬ﻳﻌﻨﻲ ﻛﻤﻲ ﺳﺎزي ﻋﻤﻠﻴﺎت‬

‫ﺑﺮﮔﺸﺖﻧﺎﭘﺬﻳﺮ اﺳﺖ(‪.‬‬

‫ﺗﺼﻮﻳﺮ ‪ (a) :6.10‬ﺗﺼﻮﻳﺮ اﺻﻠﻲ ‪(b)0‬ﻛﻤﻲ ﺳﺎزي ﻳﻜﺴﺎن ﺗﺎ ‪ 16‬ﺳﻄﺢ ))‪(c‬ﻣﻲ ﺳﺎزي اي ﺟﻲ اس ﺗﺎ ‪ 16‬ﺳﻄﺢ‬

‫‪34‬‬
‫روش ﻣﻮرد اﺳﺘﻔﺎده ﺑﺮاي ﺗﻮﻟﻴﺪ ﺗﺼﻮﻳﺮ ‪ (c)6.10‬را ﻛﻤﻲ ﺳﺎزي ﺑﻬﻴﻨﻪ ﺷﺪه ﻣﻘﻴﺎس ﺧﺎﻛﺴﺘﺮي ) )‪improved gray_scale (IGS‬‬

‫‪ (quantization‬ﻣﻲﻧﺎﻣﻴﻢ‪ .‬در اﻳﻦ ﺣﺎﻟﺖ ﺣﺴﺎﺳﻴﺖ ﭼﺸﻢ ﻧﺴﺒﺖ ﺑﻪ ﻟﺒﻪﻫﺎ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲﺷﻮد و ﺑﺎ ﺗﺨﺼﻴﺺ ﻳﻚ ﻋﺪد ﺗﺼﺎدﻓﻲ ﺑﻪ ﻫﺮ ﻋﻨﺼﺮ‬

‫ﻛﻪ از ﺑﻴﺘﻬﺎي ﺗﺤﺘﺎﻧﻲ ﭘﻴﻜﺴﻠﻬﺎي ﻣﺠﺎور ﺗﻮﻟﻴﺪ ﻣﻲﺷﻮد ﻗﺒﻞ از ﻛﻤﻲ ﺳﺎزي ﻧﺘﺎﻳﺞ آن را ﺗﺠﺰﻳﻪ ﻣﻲﻛﻨﻨﺪ‪ .‬از آﻧﺠﺎﺋﻲ ﻛﻪ ﺑﻴﺘﻬﺎي ﭘﺎﻳﻴﻦ رﺗﺒﻪ‬

‫ﺗﺼﺎدﻓﻲ ﻫﺴﺘﻨﺪ ارﻗﺎم ﺗﺼﺎدﻓﻲ ﺗﺨﺼﻴﺺ داده ﻣﻲﺷﻮﻧﺪ ﻛﻪ ﺑﺴﺘﮕﻲ ﺑﻪ ﺧﺼﻮﺻﻴﺎت ﻣﻮﺿﻌﻲ ﺗﺼﻮﻳﺮ و ﻟﺒﻪﻫﺎي ﻣﺼﻨﻮﻋﻲ ﻣﺮﺑﻮط ﺑﻪ ﻣﺤﺪوده ﺳﺎزي‬

‫ﻛﺎذب دارﻧﺪ‪ .‬ﺗﺎﺑﻊ ‪ quantize‬ﻫﻢ ﻛﻤﻲ ﺳﺎزي ﺑﻬﻴﻨﻪ ﻣﻘﻴﺎس ﺧﺎﻛﺴﺘﺮي و ﻫﻢ ﺑﺮش ﺳﻨﺘﻲ ﭘﺎﻳﻴﻦ رﺗﺒﻪ ) ‪ (low_order‬ﺑﻴﺘﻬﺎ را اﻧﺠﺎم‬

‫ﻣﻲدﻫﺪ‪ .‬ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ اﺟﺮاي ﻛﻤﻲ ﺳﺎزي ﺑﻬﻴﻨﻪ ﻣﻘﻴﺎس ﺧﺎﻛﺴﺘﺮي ﺑﺮداري اﻧﺠﺎم ﻣﻲﺷﻮد ﺗﺎ دادهﻫﺎي ورودي ‪ x‬ﻫﺮ دﻓﻌﻪ ﺑﻪ اﻧﺪازه‬

‫ﻳﻚ ﺳﺘﻮن ﭘﺮدازش ﺷﻮﻧﺪ‪ .‬ﺑﺮاي اﻳﺠﺎد ﺳﺘﻮﻧﻲ از ﻧﺘﺎﻳﺞ ‪ 4‬ﺑﻴﺘﻲ در ﺗﺼﻮﻳﺮ ‪ (c)6.10‬ﻣﺠﻤﻮع ﺳﺘﻮن ‪ s‬ﻛﻪ در اﺑﺘﺪا ﺻﻔﺮ ﻫﺴﺘﻨﺪ ﺑﻪ ﺻﻮرت ﻣﺠﻤﻮع‬

‫ﺳﺘﻮن اﻳﻜﺲ و ‪ 4‬ﺑﻴﺖ ﻣﺠﻤﻮع ﻛﻨﻮﻧﻲ اﻳﺠﺎد ﻣﻲﺷﻮد‪ .‬اﮔﺮ ‪ 4‬ﺑﻴﺖ ﻣﻬﻢ ﻫﺮ ﻳﻚ از اﻳﻜﺴﻬﺎ ‪ (1111)2‬ﺑﺎﺷﺪ در ﻋﻮض ‪ (0000)2‬اﻓﺰوده ﻣﻲﺷﻮد‪ .‬ﺑﻨﺎ‬

‫ﺑﺮ اﻳﻦ ‪ 4‬ﺑﻴﺖ ﻣﻬﻢ ﻣﺠﻤﻮع ﺣﺎﺻﻞ از آن ﺑﻪ ﻋﻨﻮان ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي رﻣﺰﮔﺬاري ﺷﺪه ﺳﺘﻮن ﭘﺮدازش ﺷﺪه ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮﻧﺪ‪.‬‬
‫)‪function y = quantize(x, b, type‬‬
‫‪%QUANTIZE Quantizes the elements of a UINT8 matrix.‬‬
‫‪%‬‬ ‫‪Y = QUANTIZE(X, 8, TYPE) quantizes X to B bits. Truncation is‬‬
‫‪%‬‬ ‫‪used unless TYPE is 'igs' for Improved Gray Scale quantization.‬‬
‫;))‪error(nargchk(2, 3, nargin‬‬ ‫‪% Check input arguments‬‬
‫… | )‪if ndims(x) ~= 2 | ~isreal(x‬‬
‫)'‪~isnumeric(x) | ~isa(x, 'uint8‬‬
‫;)'‪error('The input must be a UINT8 numeric matrix.‬‬
‫‪end‬‬

‫‪% Create bit masks for the quantization‬‬

‫;)‪lo = uint8(2 ^ (8 – b) - 1‬‬
‫;)‪hi = uint8(2 ^ 8 – double(1o) – 1‬‬

‫‪% Perform standard quantization unless IGS is specified‬‬

‫)'‪if nargin < 3 | ~strcmpi (type, 'igs‬‬
‫;)‪y = bitand(x, hi‬‬
‫‪% Else IGS quantization. Process column-wise. If the MSB's of the‬‬
‫‪% pixel are all 1's, the sum is set to the pixel value. Else, add‬‬
‫‪% the pixel value to the LSB's the previous sum. Then take the‬‬
‫‪% MSB's of the sum as the quantized value.‬‬
‫‪else‬‬
‫;)‪[m, n] = size(x‬‬ ‫;)‪s = zeros(m, 1‬‬
‫;)‪hitest = double(bitad(x, hi) ~= hi‬‬ ‫;)‪x = double(x‬‬
‫‪for j = 1:n‬‬
‫;))‪s = x(:, j) + hitest(:, j) .* double(bitand(uint8(s), 1o‬‬
‫;)‪y(:, j) = bitand(uint8(s), hi‬‬
‫‪end‬‬
‫‪end‬‬

‫‪35‬‬
‫ﻛﻤﻲ ﺳﺎزي ﺑﻬﻴﻨﻪ ﻣﻘﻴﺎس ﺧﺎﻛﺴﺘﺮي در اﻛﺜﺮ روﺷﻬﺎي ﻛﻤﻲ ﺳﺎزي ﻛﻪ ﺗﺎﺛﻴﺮ ﻣﺴﺘﻘﻴﻢ ﺑﺮ ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﺗﺼﻮﻳﺮﻫﺎي ﻫﺪف ﻓﺸﺮدهﺳﺎزي‬

‫دارﻧﺪ دﻳﺪه ﻣﻲﺷﻮد‪.‬‬

‫ﻣﻌﻤﻮﻻً ﻣﻴﺰان ﺗﻔﻜﻴﻚ ﭘﺬﻳﺮي ﻓﻀﺎﻳﻲ و ﻣﻘﻴﺎس ﺧﺎﻛﺴﺘﺮي ﻛﺎﻫﺶ ﻣﻲﻳﺎﺑﺪ‪ .‬اﮔﺮ ﺗﺼﻮﻳﺮ ﺑﺮاي ﻛﺎﻫﺶ اﻓﺰوﻧﮕﻲ ﺑﻴﻦ ﭘﻴﻜﺴﻠﻬﺎ ﻧﻘﺸﻪ ﺑﺮداري ﺷﺪه‬

‫ﺑﺎﺷﺪ‪ ،‬ﻛﻤﻲ ﺳﺎزي ﻣﻲﺗﻮاﻧﺪ ﻣﻨﺠﺮ ﺑﻪ ﻛﺎﻫﺶ ﻛﻴﻔﻲ ﺳﺎﻳﺮ ﺟﻨﺒﻪﻫﺎ ﺷﻮد ﻣﺜﻼً ﻟﺒﻪﻫﺎي ﺗﺎر )از دﺳﺖ رﻓﺘﻦ اﻃﻼﻋﺎت ﻓﺮﻛﺎﻧﺲ ﺑﺎﻻ( وﻗﺘﻲ از ﻓﺮﻛﺎﻧﺲ‬

‫ﺗﺒﺪﻳﻞ دو ﺑﻌﺪي ﺑﺮاي ارﺗﺒﺎطزداﻳﻲ دادهﻫﺎ اﺳﺘﻔﺎده ﻣﻲﺷﻮد‪.‬‬

‫ﻣﺜﺎل ‪ :6.7‬ادﻏﺎم ﻛﻤﻲ ﺳﺎزي ﺑﻬﻴﻨﻪ ﻣﻘﻴﺎس ﺧﺎﻛﺴﺘﺮي روﺷﻬﺎي رﻣﺰﮔﺬاري ﻫﺎﻓﻤﻦ و ﭘﻴﺶﺑﻴﻨﻲ ﺑﺪون اﺗﻼف اﻃﻼﻋﺎت‬

‫ﮔﺮﭼﻪ ﻛﻤﻲ ﺳﺎزي ﻛﻪ ﺑﺮاي اﻳﺠﺎد ﺗﺼﻮﻳﺮ ‪ (c)6.10‬ﺑﻪ ﻛﺎر ﺑﺮده ﺷﺪه اﺳﺖ اﻛﺜﺮ اﻓﺰوﻧﮕﻲﻫﺎي رواﻧﻲ – ﺗﺼﻮﻳﺮي ﺑﺎ ﺗﺎﺛﻴﺮ اﻧﺪك ﺑﺮ ﻛﻴﻔﻴﺖ ﺗﺼﻮﻳﺮ‬

‫ﺑﺮﻃﺮف ﻣﻲﻛﻨﺪ‪ ،‬وﻟﻲ ﺑﺮاي ﻓﺸﺮدهﺳﺎزي ﺑﻴﺸﺘﺮ از ﺷﮕﺮدﻫﺎي ‪ 2‬ﺑﺨﺶ ﻗﺒﻞ ﺑﺮاي ﻛﺎﻫﺶ اﻓﺰوﻧﮕﻲ ﺑﻴﻦ ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي و رﻣﺰﮔﺬاري اﺳﺘﻔﺎده‬

‫ﻣﻲﺷﻮد‪ .‬در واﻗﻊ ﻣﻲﺗﻮان ﻣﻴﺰان ﻓﺸﺮدهﺳﺎزي ﻛﻤﻲ ﺳﺎزي ﺑﻬﻴﻨﻪ ﻣﻘﻴﺎس ﺧﺎﻛﺴﺘﺮي را ﺗﺎ ‪ 2‬ﺑﺮاﺑﺮ اﻓﺰاﻳﺶ داد‪ .‬در ﻓﺮﻣﺎﻧﻬﺎي زﻳﺮ ﻛﻤﻲ ﺳﺎزي‬

‫ﺑﻬﻴﻨﻪ ﻣﻘﻴﺎس ﺧﺎﻛﺴﺘﺮي‪ ،‬رﻣﺰﮔﺬاري دادهﻫﺎ ﺑﺮاي ﭘﻴﺶﺑﻴﻨﻲ ﺑﺪون اﺗﻼف اﻃﻼﻋﺎت‪ ،‬و رﻣﺰﮔﺬاري ﻫﺎﻓﻤﻦ ﺑﺮاي ﻓﺸﺮدهﺳﺎزي ﺗﺼﻮﻳﺮ ‪(a).6.10‬ﺗﺎ‬

‫ﻳﻚ ﭼﻬﺎرم اﻧﺪازه اﺻﻠﻲ آن ﺑﻪ ﻛﺎر ﺑﺮده ﺷﺪه اﺳﺖ‪.‬‬

‫;)'‪>> f = imread('Brushes.tif‬‬
‫;)'‪>> q = quantize(f, 4, 'igs‬‬
‫;‪>> qs = double(q) / 16‬‬
‫;)‪>> e = mat2lpc(qs‬‬
‫;)‪>> c = mat2huff(e‬‬
‫)‪>> imratio(f, c‬‬
‫= ‪ans‬‬
‫‪4.1420‬‬

‫ﻧﺘﻴﺠﻪ رﻣﺰﮔﺬاري ‪ C‬را ﻣﻲﺗﻮان ﺑﺎ ﻣﻌﻜﻮس ﻛﺮدن روﻧﺪ ﻋﻤﻠﻴﺎت )ﺑﺪون ﻣﻌﻜﻮس ﻛﺮدن ﻛﻤﻲ ﺳﺎزي( اﻧﺠﺎم داد‪.‬‬

‫;)‪>> ne = huff2mat(c‬‬
‫;)‪>> nqs = lpc2mat(ne‬‬
‫;‪>> nq = 16 * nqs‬‬
‫)‪>> compare(q, nq‬‬
‫= ‪ans‬‬
‫‪0‬‬
‫)‪>> rmse = compare(f, nq‬‬
‫= ‪rmse‬‬
‫‪6.8382‬‬

‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﺧﻄﺎي ﺟﺬر ﻣﻴﺎﻧﮕﻴﻦ ﻣﺮﺑﻌﺎت ﺗﺼﻮﻳﺮ ﻧﺎﻓﺸﺮده ﺷﺪه ﺣﺪود ‪ 7‬ﺳﻄﺢ ﺧﺎﻛﺴﺘﺮي اﺳﺖ و رﻳﺸﻪ اﻳﻦ ﺧﻄﺎ ﻣﺮﺣﻠﻪ ﻛﻤﻲ ﺳﺎزي‬

‫اﺳﺖ‪.‬‬

‫‪36‬‬
 ‫‪ .6.5‬ﻓﺸﺮدهﺳﺎزي ﺗﺼﻮﻳﺮﻫﺎ ﺑﺎ ﭘﺴﻮﻧﺪ ‪jpeg‬‬

‫ﺷﮕﺮدﻫﺎي ﻓﺼﻠﻬﺎي ﻗﺒﻞ ﺑﺮ اﺳﺎس ﻛﺎر روي ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي اﺳﺖ‪ .‬و ﺑﻨﺎ ﺑﺮ اﻳﻦ روﺷﻬﺎي داﻣﻨﻪ ﻓﻀﺎﻳﻲ)‪(spatial domain methods‬‬

‫ﻫﺴﺘﻨﺪ‪ .‬در اﻳﻦ ﺑﺨﺶ ﻳﻚ ﺳﺮي روﺷﻬﺎي ﻓﺸﺮدهﺳﺎزي را در ﻧﻈﺮ ﻣﻲﮔﻴﺮﻳﻢ ﻛﻪ ﺑﺮ اﺳﺎس ﺗﻐﻴﻴﺮ ﺗﺒﺪﻳﻞ ﺗﺼﻮﻳﺮ ﻫﺴﺘﻨﺪ‪ .‬ﻫﺪف ﻣﺎ ﻣﻌﺮﻓﻲ‬

‫ﺗﺒﺪﻳﻠﻬﺎي ‪ 2‬ﺑﻌﺪي در ﻓﺸﺮدهﺳﺎزي ﺗﺼﻮﻳﺮ اﺳﺖ‪.‬‬

‫ﺑﺮاي ﺗﺸﺮﻳﺢ ﻧﺤﻮه ﻛﺎﻫﺶ اﻓﺰوﻧﮕﻲ ﺗﺼﻮﻳﺮ در ﺑﺨﺸﻬﺎي ‪ 6.2‬ﺗﺎ ‪ 6.4‬ﺑﺎ ﻣﺜﺎﻟﻬﺎي ﺑﻴﺸﺘﺮ و ﺑﺮاي ﻣﻄﻠﻊ ﻛﺮدن ﺧﻮاﻧﻨﺪﮔﺎن از روﺷﻬﺎي ﻫﻨﺮي‬

‫ﻓﺸﺮدهﺳﺎزي ﺗﺼﻮﻳﺮ ﺑﺎﻳﺪ ﺑﮕﻮﻳﻴﻢ ﻛﻪ اﺳﺘﺎﻧﺪاردﻫﺎي ﻋﺮﺿﻪ ﺷﺪه )ﻛﻪ ﻣﻮارد ﻧﺰدﻳﻚ ﺑﻪ آﻧﻬﺎ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲﺷﻮﻧﺪ( ﺑﺮاي ﻛﺎر ﺑﺎ اﻧﻮاع ﺗﺼﻮﻳﺮﻫﺎ و‬

‫ﺷﺮاﻳﻂ ﻓﺸﺮدهﺳﺎزي اﺳﺖ‪.‬‬

‫در رﻣﺰﮔﺬاري ﺗﺒﺪﻳﻠﻲ ﻣﺎﻧﻨﺪ ﻳﻚ ﺗﺒﺪﻳﻞ ﺧﻄﻲ ﺑﺮﮔﺸﺖﭘﺬﻳﺮ ﻫﻤﭽﻮن ‪ DFT‬ﻓﺼﻞ ‪ 4‬ﻳﺎ ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ‪DCT‬‬
‫‪M −1N −1‬‬
‫‪ (2 x + 1)uπ ‬‬ ‫‪ (2 x + 1)vπ ‬‬
‫= )‪T (u , v‬‬ ‫‪∑ ∑ f ( x, y)a(u )a(v) cos‬‬ ‫‪2M‬‬ ‫‪‬‬
‫‪‬‬
‫‪cos ‬‬
‫‪ 2N‬‬ ‫‪‬‬
‫‪x =0 y =0‬‬

‫‪ 1‬‬
‫‪‬‬ ‫‪u=0‬‬
‫‪a (u ) =  M‬‬
‫‪ 2 u = 1,2,..., M − 1‬‬
‫‪ M‬‬
‫‪ T (u , v) ‬‬
‫‪Tˆ (u , v) = round ‬‬ ‫‪‬‬
‫‪ Z (u , v) ‬‬
‫‪ αv‬ﺑﺮاي ﻧﻘﺸﻪ ﺑﺮداري ﺗﺼﻮﻳﺮ روي ﺿﺮاﻳﺐ ﺗﺒﺪﻳﻞ ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮد ﻛﻪ ﭘﺲ از آن ﻛﻤﻲ ﺳﺎزي و رﻣﺰﮔﺬاري ﻣﻲﺷﻮﻧﺪ‪ .‬در اﻛﺜﺮ ﺗﺼﻮﻳﺮﻫﺎي‬

‫ﻃﺒﻴﻌﻲ ﺑﻴﺸﺘﺮ ﺿﺮاﻳﺐ ﺑﺰرﮔﻲ اﻧﺪﻛﻲ دارﻧﺪ و ﻣﻲﺗﻮان آﻧﻬﺎ را ﺑﺎ ﺗﺤﺮﻳﻒ اﻧﺪك ﺗﺼﻮﻳﺮ ﻛﻤﻲ ﺳﺎزي ﻛﺮد‪.‬‬

‫‪Jpeg .6.5.1‬‬

‫ﻳﻜﻲ از ﻣﺤﺒﻮﺑﺘﺮﻳﻦ و ﻛﺎﻣﻠﺘﺮﻳﻦ اﺳﺘﺎﻧﺪاردﻫﺎي ﻓﺸﺮدهﺳﺎزي ﺗﺼﻮﻳﺮﻫﺎي ﺛﺎﺑﺖ ﭘﺴﻮﻧﺪ ‪) jpeg‬ﻣﺨﻔﻒ ﮔﺮوه ﻣﺘﺨﺼﺼﺎن ﺗﺼﻮﻳﺮﺑﺮداري‬

‫ﻣﺸﺘﺮك()‪ (Joint Photographic Expert Group‬اﺳﺖ‪ .‬در ﺳﻴﺴﺘﻢ رﻣﺰﮔﺬاري ﻣﺒﻨﺎي اﻳﻦ ﭘﺴﻮﻧﺪ ﻛﻪ ﺑﺮ اﺳﺎس ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮس ﻣﺘﻤﺎﻳﺰ‬

‫اﺳﺖ و ﺑﺮاي اﻛﺜﺮ ﺑﺮﻧﺎﻣﻪﻫﺎي ﻛﺎرﺑﺮدي ﻛﺎﻓﻲ اﺳﺖ ﺗﺼﻮﻳﺮﻫﺎي ورودي و ﺧﺮوﺟﻲ ﻣﺤﺪود ﺑﻪ ‪ 8‬ﺑﻴﺖ ﻣﻲﺷﻮﻧﺪ در ﺻﻮرﺗﻲ ﻛﻪ ﻣﻘﺎدﻳﺮ ﺿﺮاﻳﺐ‬

‫ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ ﻣﺤﺪود ﺑﻪ ‪ 11‬ﺑﻴﺖ ﻣﻲﺷﻮﻧﺪ‪ .‬ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﻧﻤﻮدار ﺳﺎده ﺷﺪه ﺗﺼﻮﻳﺮ ‪a6.11‬دﻳﺪه ﻣﻲﺷﻮد‪ ،‬اﻳﻦ ﻓﺸﺮدهﺳﺎزي در ‪4‬‬

‫ﻣﺮﺣﻠﻪ ﭘﻲ درﭘﻲ ﺑﻪ ﻧﺎﻣﻬﺎي اﺳﺘﺨﺮاج ﺗﺼﻮﻳﺮ ﻓﺮﻋﻲ ‪ ،8*8‬ﻣﺤﺎﺳﺒﻪ ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ ﻛﻤﻲ ﺳﺎزي و ﺗﺨﺼﻴﺺ رﻣﺰي ﺑﺎ ﻃﻮل ﻣﺘﻐﻴﺮ اﻧﺠﺎم‬

‫ﻣﻲﺷﻮد‪.‬‬

‫‪37‬‬
‫ﻣﺮﺣﻠﻪ اول در ﻓﺸﺮدهﺳﺎزي ﺑﺎ ﭘﺴﻮﻧﺪ ‪ jpeg‬ﺗﻘﺴﻴﻢ ﺗﺼﻮﻳﺮ ورودي ﺑﻪ ﻗﻄﻌﺎت ﺗﺼﻮﻳﺮي ﺑﺪون ﻫﻤﭙﻮﺷﻲ ﺑﻪ اﻧﺪازه ‪ 8*8‬اﺳﺖ‪ .‬ﺳﭙﺲ آﻧﻬﺎ از ﭼﭗ‬

‫ﺑﻪ راﺳﺖ و ﺑﺎﻻ ﺑﻪ ﭘﺎﻳﻴﻦ ﭘﺮدازش ﻣﻲﺷﻮﻧﺪ‪ .‬ﺣﻴﻦ ﭘﺮدازش ﻫﺮ ﻳﻚ از ﻗﻄﻌﺎت ‪ 8*8‬ﭘﻴﻜﺴﻠﻬﺎي ‪ 64‬آن ﺑﺎ ﺗﻔﺮﻳﻖ ‪ 2m-1‬ﺟﺎﺑﺠﺎ ﻣﻲﺷﻮﻧﺪ ﻛﻪ در‬

‫اﻳﻨﺠﺎ ‪ 2‬ﺗﻌﺪاد ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﺗﺼﻮﻳﺮ اﺳﺖ و ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ ‪ 2‬ﺑﻌﺪي آن ﻣﺤﺎﺳﺒﻪ ﻣﻲﺷﻮد‪.‬‬

‫ﺗﺼﻮﻳﺮ ‪ (a) :6.12‬آراﻳﻪ ﻫﻨﺠﺎرﻣﻨﺪ ﻛﻨﻨﺪه ﺗﺼﻮﻳﺮﻫﺎي ‪ jpeg‬در ﺣﺎﻟﺖ ﭘﻴﺶ ﻓﺮض )‪ (b‬ﺗﻮاﻟﻲ ﺗﺮﺗﻴﺐ ﺿﺮﻳﺐ زﻳﮕﺰاگ ‪jpeg‬‬

‫ﺳﭙﺲ ﺿﺮاﻳﺐ ﺣﺎﺻﻞ از آن ﻫﻤﺰﻣﺎن ﻣﻄﺎﺑﻖ ﺑﺎ راﺑﻄﻪ زﻳﺮ ﻫﻨﺠﺎرﻣﻨﺪ و ﻛﻤﻲ ﺳﺎزي ﻣﻲﺷﻮﻧﺪ‪.‬‬

‫?‬

‫در اﻳﻨﺠﺎ )‪ (u,v=0,1,…,7) T(u, v‬ﺿﺮاﻳﺐ ﻫﻨﺠﺎرﻣﻨﺪ ﺳﺎزي و ﻛﻤﻲ ﺳﺎزي ﻫﺴﺘﻨﺪ و )‪ T (u, v‬ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ‪ DCT‬ﺗﺼﻮﻳﺮ‬

‫‪ f(x, y) 8*8‬اﺳﺖ و )‪ z(u, v‬آراﻳﻪ ﻫﻨﺠﺎرﻣﻨﺪ ﺗﺒﺪﻳﻞ)‪ (Transform normalization‬اﺳﺖ ﻛﻪ ﻣﺎﻧﻨﺪ ﺗﺼﻮﻳﺮ ‪ (a)6.12‬اﺳﺖ‪ .‬ﺑﺎ ﻣﻘﻴﺎس‬

‫ﺑﻨﺪي )‪ z(u, v‬ﻣﻲﺗﻮان اﻧﻮاع ﻧﺴﺒﺘﻬﺎي ﻓﺸﺮدهﺳﺎزي را اﺟﺮا و ﺧﺼﻮﺻﻴﺎت ﺗﺼﻮﻳﺮ را ﺑﺎزﺳﺎزي ﻛﺮد‪.‬‬

‫ﭘﺲ از ﻛﻤﻲ ﺳﺎزي ﺿﺮاﻳﺐ ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ‪ DCT‬ﻫﺮ ﺑﻠﻮك ﻋﻨﺎﺻﺮ )‪ T(u, v‬ﻣﻄﺎﺑﻖ ﺑﺎ اﻟﮕﻮي زﻳﮕﺰاگ ﺗﺼﻮﻳﺮ ‪ (b).6.12‬ﺛﺒﺖ‬

‫ﻣﻲﺷﻮﻧﺪ‪ .‬از آﻧﺠﺎﺋﻲ ﻛﻪ آراﻳﻪ ﻣﺮﺗﺐ ﺷﺪه ﺗﻚ ﺑﻌﺪي )ﺿﺮاﻳﺐ ﻛﻤﻲ ﺳﺎزي ﺷﺪه( ﺑﺮ ﺣﺴﺐ اﻓﺰاﻳﺶ ﻓﺮﻛﺎﻧﺲ ﻓﻀﺎﻳﻲ ﺑﻪ ﺷﻜﻞ ﻛﻴﻔﻲ ﻣﺮﺗﺐ‬

‫ﻣﻲﺷﻮد رﻣﺰﮔﺬار ﻧﻤﺎد ﺗﺼﻮﻳﺮ ‪ (a)6.11‬ﺑﺮاي ﺑﻬﺮهﺑﺮداري از اﺟﺮاﻫﺎي ﻃﻮﻻﻧﻲ ﺻﻔﺮ ﻃﺮاﺣﻲ ﺷﺪه اﺳﺖ ﻛﻪ ﺑﻌﺪ از ﺛﺒﺖ ﺑﻪ دﺳﺖ ﻣﻲآﻳﻨﺪ‪ .‬ﺿﺮاﻳﺐ‬

‫‪38‬‬
 ‫ ﺑﺎ اﺳﺘﻔﺎده از ﻛﺪي ﺑﺎ ﻃﻮل ﻣﺘﻐﻴﺮ رﻣﺰﮔﺬاري ﻣﻲﺷﻮﻧﺪ ﻛﻪ ﻣﻘﺪار ﺿﺮﻳﺐ و ﺗﻌﺪاد ﺻﻔﺮﻫﺎي ﻗﺒﻞ را‬u=v=0 ‫ ﺑﻪ ﻏﻴﺮ از‬T(u, v) ‫ ﻏﻴﺮﺻﻔﺮ‬AC

‫ ﺟﺪول‬.‫ ﺗﺼﻮﻳﺮ ﻓﺮﻋﻲ ﻗﺒﻞ دارد‬DC ‫ ﺿﺮﻳﺐ ﻛﺴﻴﻨﻮس ﻣﺘﻤﺎﻳﺰ ﺑﻪ ﺷﻜﻠﻲ ﻣﺘﻔﺎوت رﻣﺰﮔﺬاري ﻣﻲﺷﻮد ﻛﻪ ﺑﺴﺘﮕﻲ ﺑﻪ ﺿﺮﻳﺐ‬.‫ﺗﻌﺮﻳﻒ ﻣﻲﻛﻨﺪ‬

‫ وﻟﻲ ﻛﺎرﺑﺮ ﻣﻲﺗﻮاﻧﺪ ﺟﺪوﻟﻬﺎي ﺳﻔﺎرﺷﻲ و آراﻳﻪﻫﺎي ﻫﻨﺠﺎرﺳﺎزي ﺧﻮدش را‬.‫ ﻫﺎﻓﻤﻦ ﻃﺒﻖ اﺳﺘﺎﻧﺪاردﻫﺎ اراﺋﻪ ﺷﺪه اﺳﺖ‬AC ‫ و‬DC ‫رﻣﺰﮔﺬاري‬

.‫اﻳﺠﺎد ﻛﻨﺪ ﻛﻪ ﻣﻲﺗﻮاﻧﻨﺪ ﺑﺎ ﺧﺼﻮﺻﻴﺎت ﺗﺼﻮﻳﺮ ﻓﺸﺮده ﺷﺪه وﻓﻖ داده ﺷﻮﻧﺪ‬

‫زﻳﺮ ﻓﺮاﻳﻨﺪ رﻣﺰﮔﺬاري ﻣﺒﻨﺎي ﻣﺸﺎﺑﻪ‬M file, m‫ در اﻳﻦ ﻓﺼﻞ اﻣﻜﺎنﭘﺬﻳﺮ ﻧﻴﺴﺖ وﻟﻲ ﭘﺮوﻧﺪهﻫﺎي‬jpeg ‫ﺗﺸﺮﻳﺢ اﺟﺮاي ﻛﺎﻣﻞ اﺳﺘﺎﻧﺪاردﻫﺎي‬

:‫دارﻧﺪ‬
function y = im2jpeg(x, quality)
%IM2JPEG Compresses an image using a JPEG approximation.
% Y = IM2JPEG(X, QUALITY) Compresses image X based on 8 x 8 DCT
% transforms, coefficient quantization, and Huffman symbol
% coding. Input QUALITY determines the amount of information that
% is lost and compression achieved. Y is an encoding structure
% containing fields:
%
% Y.size size of X
% Y.numblocks Number of 8-by-8 encoded blocks
% Y.quality Quality factor (as percent)
% Y.huffman Huffman encoding structure, as returned by
% MAT2HUFF
%
% See also JPEG2IM.
error(nargchk(1, 2, nargin)); % Check input arguments
if nargin(x) ~= 2 | ~isreal(x) | ~isnumeric(x) | ~isa(x, 'uint8')
error('The input must be a UINT8 image.');
end
if nargin < 2
quality = 1; % Default value for quality.
End
m = [ 16 11 10 16 24 40 51 61 % JPEG normalizing array
12 12 14 19 26 58 60 55 % and zig-zag reordering
14 13 16 24 40 57 69 56 % Pattern.
14 17 22 29 51 87 80 62
18 22 37 56 68 109 103 77
24 35 55 64 81 104 113 92
49 64 78 87 103 121 120 101
72 92 95 98 112 100 103 99] * quality;

order = [1 9 2 3 10 17 25 18 11 4 5 12 19 26 33 …
41 34 27 20 13 6 7 14 21 28 35 42 49 57 50 …
43 36 29 22 15 8 16 23 30 37 44 51 58 59 52 …
45 38 31 24 32 39 46 53 60 61 54 47 40 48 55 …
62 63 56 64 ];
[xm, xn] = size(x); % Get input size.
x = double(x) – 128; % Level shift input
t = dctmtx(8); % Compute 8 x 8 DCT matrix

% Compute DCTs of 8x8 blocks and quantize the coefficients.

y = blkproc(x, [8 8], 'p1 * x * p2', t, t');
y = blkproc(x, [8 8], 'round(x ./ p1)', m);

y = im2col(y, [8 8], 'distinct'); % Break 8x8 blocks into columns

39
‫;)‪xb = size(y, 2‬‬ ‫‪% Get number of blocks‬‬
‫;)‪y = y(order, :‬‬ ‫‪% Reorder column elements‬‬
‫;‪eob = max(x(:)) + 1‬‬ ‫‪% Create end-of-block symbol‬‬
‫;)‪r = zeros(numel(y) + size(y, 2), 1‬‬
‫;‪count = 0‬‬
‫‪for j = 1:xb‬‬ ‫‪% Process 1 block (col) at a time‬‬
‫;))))‪i = max(find(y(:, j‬‬ ‫‪% Find last non-zero element‬‬
‫)‪if isempty(i‬‬ ‫‪% Ni nonzero block values‬‬
‫;‪i = 0‬‬
‫‪end‬‬
‫;‪p = count + 1‬‬
‫;‪q = p + I‬‬
‫;]‪r(p:q) = [y(1:i, j); eob‬‬ ‫‪% Truncate trailing 0's, add EOB,‬‬
‫;‪count = count + i + 1‬‬ ‫‪% and add to output vector‬‬
‫‪end‬‬
‫;][ = )‪r((count + 1):end‬‬ ‫‪% Delete unused portion of r‬‬
‫‪%‬‬ ‫‪Y.size‬‬ ‫;)]‪= uint16([xm xn‬‬
‫‪%‬‬ ‫;)‪Y.numblocks = uint16(xb‬‬
‫‪%‬‬ ‫‪Y.quality‬‬ ‫;)‪= uint16(quality * 100‬‬
‫‪%‬‬ ‫‪Y.huffman‬‬ ‫;)‪= mat2huff(r‬‬

‫ﺗﺎﺑﻊ ‪ im2jpeg‬ﻣﻄﺎﺑﻖ ﺑﺎ ﻧﻤﻮدار ﺗﺼﻮﻳﺮ ‪(a).6.11‬ﻗﺴﻤﺘﻬﺎي ‪ 8*8‬ﻣﺘﻤﺎﻳﺰ و ﻳﺎ ﻗﻄﻌﻪﻫﺎي ﺗﺼﻮﻳﺮ ورودي‪ x‬را ﺗﻚ ﺑﻪ ﺗﻚ )ﺑﻪ ﺟﺎي ﭘﺮدازش‬

‫ﻳﻜﺠﺎي ﺗﺼﻮﻳﺮ( ﭘﺮدازش ﻣﻲﻛﻨﺪ‪ 2 blkproc, im2col .‬ﺗﺎﺑﻊ ﻣﺨﺼﻮص ﭘﺮدازش ﻗﻄﻌﻪﻫﺎ ﻫﺴﺘﻨﺪ ﻛﻪ ﺑﺮاي ﺳﺎده ﺳﺎزي ﻣﺤﺎﺳﺒﺎت ﺑﻪ ﻛﺎر ﺑﺮده‬

‫ﻣﻲﺷﻮﻧﺪ‪ .‬ﺗﺎﺑﻊ ‪ blkproc‬ﻛﻪ ﺗﺮﻛﻴﺐ اﺳﺘﺎﻧﺪارد آن ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ‪:‬‬

‫‪B = blkproc(A, [M N], FUNCTION, P1, P2, …),‬‬

‫ﻓﺮاﻳﻨﺪ ﻛﺎر ﺑﺎ ﺗﺼﻮﻳﺮﻫﺎ را ﺳﺮﻳﻊ و ﺧﻮدﻛﺎر ﻣﻲﻛﻨﺪ‪ .‬ﺗﺼﻮﻳﺮ ورودي )‪(a‬را ﻫﻤﺮاه ﺑﺎ اﻧﺪازه ﻗﻄﻌﺎت آﻣﺎده ﭘﺮدازش درﻳﺎﻓﺖ ﻣﻲﻛﻨﺪ ﺳﭙﺲ از ﺗﺎﺑﻌﻲ‬

‫ﺑﺮاي ﭘﺮدازش آﻧﻬﺎ اﺳﺘﻔﺎده ﻣﻲﺷﻮد ﻛﻪ ﭘﺎراﻣﺘﺮﻫﺎي ورودي اﺧﺘﻴﺎري ‪ p1, p2‬و ﻏﻴﺮه را ﺑﺮاي ﺗﺎﺑﻊ ﭘﺮدازش دارﻧﺪ‪ .‬ﺳﭙﺲ ﺗﺎﺑﻊ ‪ a blkproc‬را ﺑﻪ‬

‫ﻗﻄﻌﺎت ‪) m*n‬ﻫﻤﺮاه ﺑﺎ ﻫﺮ ﻧﻮع ﻻﻳﻪﮔﺬاري ﺻﻔﺮ( ﺗﺠﺰﻳﻪ ﻣﻲﻛﻨﺪ‪ .‬ﺑﺎ ﻫﺮ ﺑﻠﻮك ‪ .‬ﭘﺎراﻣﺘﺮﻫﺎي ‪ p1, p2‬ﺗﺎﺑﻊ ‪ FUN‬را ﻓﺮاﺧﻮاﻧﻲ ﻣﻲﻛﻨﺪ و ﻧﺘﺎﻳﺞ را‬

‫در ﺗﺼﻮﻳﺮ ﺧﺮوﺟﻲ ب ﻗﺮار ﻣﻲدﻫﺪ‪.‬‬

‫دوﻣﻴﻦ ﺗﺎﺑﻊ ﻣﺨﺼﻮص ﭘﺮدازش ﺑﻠﻮك ﻛﻪ ﺗﻮﺳﻂ ‪ im2jpeg‬اﺳﺘﻔﺎده ﻣﻲﺷﻮد ‪ im2col‬اﺳﺖ‪ .‬وﻗﺘﻲ ‪ blkproc‬ﺑﺮاي اﺟﺮاي ﻋﻤﻠﻴﺎت روي‬

‫ﻗﻄﻌﺎت ﻣﻨﺎﺳﺐ ﻧﺒﺎﺷﺪ‪ im2col ،‬ﺑﺮاي ﻣﺮﺗﺐ ﺳﺎزي دادهﻫﺎي ورودي ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮد ﻃﻮري ﻛﻪ ﺑﺘﻮان ﻋﻤﻠﻴﺎت را ﺑﻪ ﻛﻠﻲ ﺳﺎدهﺗﺮ و‬

‫ﻛﺎرآﻣﺪﺗﺮ اﻧﺠﺎم داد‪) .‬ﻣﺜﻼً ﺑﺎ ﺑﺮدارﺑﻨﺪي ﻋﻤﻠﻴﺎت(‪ .‬دادهﻫﺎي ﺧﺮوﺟﻲ ‪ im2col‬ﻣﺎﺗﺮﻳﺴﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﻫﺮ ﻳﻚ از ﺳﺘﻮﻧﻬﺎي آن ﺣﺎوي ﻋﻨﺎﺻﺮ ﻳﻚ‬

‫ﻗﻄﻌﻪ ﻣﺘﻤﺎﻳﺰ از ﺗﺼﻮﻳﺮ ورودي اﺳﺖ‪ .‬ﻗﺎﻟﺐ اﺳﺘﺎﻧﺪارد آن ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ‪:‬‬
‫)'‪B = im2col(A, [M N], 'distinct‬‬

‫‪40‬‬
‫در اﻳﻨﺠﺎ ﭘﺎراﻣﺘﺮﻫﺎي ]‪ A,B,[M,N‬ﻗﺒﻼٌ در ﺗﺎﺑﻊ ‪ blkproc‬ﺗﻌﺮﻳﻒ ﺷﺪﻧﺪ‪ .‬رﺷﺘﻪ ‪ distinct‬ﺑﻪ ‪ im2col‬ﻣﻲﮔﻮﻳﺪ ﻛﻪ ﻗﻄﻌﺎت ﭘﺮدازش ﺷﺪه‬

‫ﻫﻤﭙﻮﺷﻲ ﻧﺪارﻧﺪ‪ .‬رﺷﺘﻪ ‪ sliding‬اﻳﺠﺎد ﻳﻚ ﺳﺘﻮن را در ‪ b‬ﺑﻪ ازاي ﻫﺮ ﻋﻨﺼﺮ ﺗﺼﻮﻳﺮي ‪ a‬ﻧﺸﺎن ﻣﻲدﻫﺪ )ﮔﻮﻳﻲ ﻳﻚ ﻗﻄﻌﻪ در ﺗﺼﻮﻳﺮ درج ﺷﺪه‬

‫اﺳﺖ(‪.‬‬

‫ﺗﺎﺑﻊ ‪ blkproc‬در ‪ im2jpeg‬ﺑﺮاي ﺗﺴﻬﻴﻞ ﻣﺤﺎﺳﺒﺎت ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ و ﻛﻤﻲ ﺳﺎزي و ﻫﻨﺠﺎرزداﻳﻲ ﺿﺮﻳﺐ ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮﻧﺪ در‬

‫ﺣﺎﻟﻲ ﻛﻪ ‪ im2col‬ﺑﺮاي ﺳﺎده ﺳﺎزي ﺗﻨﻈﻴﻢ ﻣﺠﺪد ﺿﺮاﻳﺐ ﻛﻤﻲ ﺷﺪه و ﻛﺸﻒ اﺟﺮاﻫﺎي ﺻﻔﺮ ﺑﻪ ﻛﺎر ﺑﺮده ﻣﻲﺷﻮد‪ Im2jpeg .‬ﺑﺮ ﺧﻼف‬

‫اﺳﺘﺎﻧﺪارد ‪ jpeg‬ﻓﻘﻂ اﺟﺮاﻫﺎي آﺧﺮ ﺻﻔﺮ را در ﻫﺮ ﻗﻄﻌﻪ ﺿﺮﻳﺐ ﻣﺮﺗﺐ ﺷﺪه ﻧﺸﺎن ﻣﻲدﻫﺪ و ﻛﻞ اﺟﺮاي آن را ﺑﺎ ﻧﻤﺎد ‪ eob‬ﺟﺎﻳﮕﺰﻳﻦ ﻣﻲﻛﻨﺪ‪.‬‬

‫ﮔﺮﭼﻪ ﻧﺮم اﻓﺰار ‪ MATLAB‬ﻳﻚ ﺗﺎﺑﻊ ﻛﺎرآﻣﺪ ﻣﺒﺘﻨﻲ ﺑﺮ ‪ FFT‬ﺑﺮاي ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ‪ DCT‬ﺗﺼﻮﻳﺮﻫﺎي ﺑﺰرگ دارد )ﻛﻪ در ﻣﻄﺎﻟﺐ‬

‫راﻫﻨﻤﺎي ﺗﺎﺑﻊ ‪ dct2‬ﺗﺸﺮﻳﺢ ﺷﺪه اﺳﺖ( وﻟﻲ ‪ im2jpeg‬از ﻳﻚ ﻓﺮﻣﻮل ﻣﺎﺗﺮﻳﺴﻲ دﻳﮕﺮ اﺳﺘﻔﺎده ﻣﻲﻛﻨﺪ‪.‬‬

‫‪T = HFH T‬‬

‫در اﻳﻨﺠﺎ ‪ f‬ﺑﻠﻮك ‪ 8*8‬ﺗﺼﻮﻳﺮ )‪ f(x, y‬اﺳﺖ و ‪ H‬ﺗﺒﺪﻳﻞ ‪ 8*8‬ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ و ﻣﺎﺗﺮﻳﺲ اﻳﺠﺎد ﺷﺪه ﺗﻮﺳﻂ ‪ .dctmtx8‬اﺳﺖ و ‪T‬‬

‫ﻧﺘﻴﺠﻪ ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ ‪ f‬اﺳﺖ‪.‬‬

‫‪ T‬ﺑﺮاي ﻧﺸﺎن دادن ﻋﻤﻠﻴﺎت ﺟﺎﺑﺠﺎﻳﻲ ﺑﻪ ﻛﺎر ﻣﻲرود‪ .‬در ﺻﻮرت اﻧﺠﺎم ﻧﺸﺪن ﻛﻤﻲ ﺳﺎزي ﻣﻌﻜﻮس ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ ﺗﻲ ﺑﻪ ﺷﺮح زﻳﺮ‬

‫اﺳﺖ‪:‬‬

‫‪F = H T TH‬‬
‫اﻳﻦ ﻓﺮﻣﻮل ﻣﺨﺼﻮﺻﺎً وﻗﺘﻲ ﻣﻮﺛﺮ اﺳﺖ ﻛﻪ ﺗﺼﻮﻳﺮﻫﺎي ﻣﺮﺑﻊ ﺷﻜﻞ ﻛﻮﭼﻚ )ﻣﺎﻧﻨﺪ ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ ‪ (8*8‬ﺗﺒﺪﻳﻞ ﻣﻲﺷﻮﻧﺪ‪ .‬ﺑﻨﺎ ﺑﺮ اﻳﻦ‬

‫ﻋﺒﺎرت زﻳﺮ‬
‫)'‪y = blkproc(x, [8 8], 'P1 * x * P2', h, h‬‬

‫ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ ﺗﺼﻮﻳﺮ‪ x‬را در ﻗﻄﻌﺎت ‪ 8*8‬ﺑﺎ اﺳﺘﻔﺎده از ﻣﺎﺗﺮﻳﺲ ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ‪ h‬اﻧﺠﺎم ﻣﻲدﻫﺪ و ﺟﺎﺑﺠﺎﻳﻲ ‪ h‬ﺑﻪ ﺻﻮرت‬

‫ﭘﺎراﻣﺘﺮﻫﺎي‪ p1‬و ‪ p2‬ﺿﺮب ﻣﺎﺗﺮﻳﺲ ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ‪ DCT‬ﻫﺴﺘﻨﺪ‪.‬‬

‫ﺑﺮاي ﻧﺎﻓﺸﺮده ﻛﺮدن ﺗﺼﻮﻳﺮ ‪ im2jpeg‬ﻗﻄﻌﺎت ﺑﺎﻳﺪ ﭘﺮدازش و ﺑﺮ اﺳﺎس ﻣﺎﺗﺮﻳﺲ ﺗﺒﺪﻳﻞ ﺷﻮﻧﺪ‪ .‬ﺗﺎﺑﻊ ‪ jpeg2im‬ﻋﻤﻠﻴﺎت ﻣﻌﻜﻮسﺳﺎزي را )ﺑﻪ‬

‫اﺳﺘﺜﻨﺎي ﻛﻤﻲ ﺳﺎزي( ﻳﻚ ﺑﻪ ﻳﻚ اﻧﺠﺎم ﻣﻲدﻫﺪ‪.‬‬

‫‪A = col2im(B, [M N], [MM NN],‬‬ ‫)'‪'distinct‬‬

‫)‪function x= jpeg2im(y‬‬
‫‪%JPEG2IM Decode an IM2JPEG compressed image.‬‬
‫‪%‬‬ ‫‪X = JPEG2IM(Y) decodes compresses image Y, generationg‬‬
‫‪%‬‬ ‫‪reconstructed approximation X. Y is a structure generated by‬‬
‫‪%‬‬ ‫‪IM2JPEG‬‬
‫‪%‬‬

‫‪41‬‬
 % See also IM2JPEG.
error(nargchk(1, 1, nargin)); % Check input arguments

m = [ 16 11 10 16 24 40 51 61 % JPEG normalizing array

12 12 14 19 26 58 60 55 % and zig-zag reordering
14 13 16 24 40 57 69 56 % Pattern.
14 17 22 29 51 87 80 62
18 22 37 56 68 109 103 77
24 35 55 64 81 104 113 92
49 64 78 87 103 121 120 101
72 92 95 98 112 100 103 99];

order = [1 9 2 3 10 17 25 18 11 4 5 12 19 26 33 …
41 34 27 20 13 6 7 14 21 28 35 42 49 57 50 …
43 36 29 22 15 8 16 23 30 37 44 51 58 59 52 …
45 38 31 24 32 39 46 53 60 61 54 47 40 48 55 …
62 63 56 64 ];
rev = order; % Compute inverse ordering
for k = 1:length(r=order)
rev(k) = find(order == k);
end
m = double(y.quality) / 100 * m; % Get encoding quality.
Xb = double(y.numblocks) % Get x blocks.
sz = double(y.size);
xn = sz(2); % Get x columns.
xm = sz(1); % Get x rows.
x = huff2mat(y.huffman); % Huffman decode.
eob = max(x(:)); % Get end-of-block symbol
z = zeros(64, xb); k = 1; % Form block columns by copying
for j = 1:xb % successive values from x into
for i = 1:64 % columns of z, while changing
if x(k) == eob % to the next column whenever
k = k + 1: break; % an EOB symbol is found.
else
z(i, j) = x(k);
k = k + 1;
end
end
end

z = z(rev, :); % Restore order

x = col2im(z, [8 8], [xm xn], 'distinct'); % Form matrix blocks
x = blkproc(x , [8 8], 'x .* P1', m); % Denormalize DCT
t = dctmtx(8); % Get 8 x 8 DCT matrix
x = blkproc(x , [8 8], 'P1 * x * p2', t', t); % Compute block DCT-1
x = uint8(x + 128); % Level shift

‫ ﺗﺼﻮﻳﺮ ﺑﺎزﺳﺎزي ﺷﺪه اﺳﺖ از ﺗﺎﺑﻌﻬﺎي‬8*8 ‫ ﻋﻨﺼﺮي ﻳﻚ ﻗﻄﻌﻪ‬64 ‫ ﻛﻪ ﻫﺮ ﻳﻚ از ﺳﺘﻮﻧﻬﺎي‬z ‫ ﺑﻌﺪي از ﺳﺘﻮﻧﻬﺎي ﻣﺎﺗﺮﻳﺲ‬2 ‫ﺑﺮاي ﺑﺎز ﻳﻚ ﺗﺼﻮﻳﺮ‬

‫ اﺑﻌﺎد‬mm, mn, ‫ ﺗﻌﺮﻳﻒ ﺷﺪهاﻧﺪ در ﺣﺎﻟﻲ ﻛﻪ آراﻳﻪ‬im2col ‫ ﻗﺒﻼٌ ﺑﺮاي ﺗﺎﺑﻊ‬A,B,[M,N], distinct ‫ ﭘﺎراﻣﺘﺮﻫﺎي‬.‫ﻋﻤﻮﻣﻲ اﺳﺘﻔﺎده ﻣﻲﻛﻨﺪ‬

.‫ را ﻧﺸﺎن ﻣﻲدﻫﺪ‬a ‫ﺗﺼﻮﻳﺮ ﺧﺮوﺟﻲ‬

42
 ‫ﻣﺜﺎل ‪:6.8‬‬

‫در ﺗﺼﺎوﻳﺮ ‪ (a)6.13‬و )‪ 2 ,(b‬ﺗﺼﻮﻳﺮ رﻣﺰﮔﺬاري ﺷﺪه و رﻣﺰﮔﺸﺎﻳﻲ ﺷﺪه ﺑﺎ ‪ jpeg‬و ﻣﻘﺎدﻳﺮ ﺗﻘﺮﻳﺒﻲ ﺗﺼﻮﻳﺮ ﺗﻚ رﻧﮓ ‪ (a)6.4‬دﻳﺪه ﻣﻲﺷﻮﻧﺪ‪.‬‬

‫ﻧﺴﺒﺖ ﻓﺸﺮدهﺳﺎزي ﻧﺘﻴﺠﻪ اول ‪ 18‬ﺑﻪ ‪ 1‬اﺳﺖ ﺑﺎ اﺟﺮاي ﻣﺴﺘﻘﻴﻢ آراﻳﻪ ﻫﻨﺠﺎرﺳﺎزي در ﺗﺼﻮﻳﺮ ‪(a)6.12‬ﺑﻪ دﺳﺖ آﻣﺪ‪.‬‬

‫دوﻣﻴﻦ ﻣﻮرد ﻛﻪ ﺗﺼﻮﻳﺮ اﺻﻠﻲ را ﺑﻪ ﻧﺴﺒﺖ ‪ 42‬ﺑﻪ ‪ 1‬ﻓﺸﺮدهﺳﺎزي ﻛﺮده اﺳﺖ ﺑﺎ ﺿﺮب ﻛﺮدن آراﻳﻪ ﻫﻨﺠﺎرﺳﺎزي در ‪ 4‬اﻳﺠﺎد ﺷﺪ‪.‬‬

‫اﺧﺘﻼف ﺑﻴﻦ ﺗﺼﻮﻳﺮ اﺻﻠﻲ ﻋﻜﺲ ‪ (a)6.4‬و ﺗﺼﻮﻳﺮ ﺑﺎزﺳﺎزي ﺷﺪه ﻋﻜﺲ ‪ (a)6.13‬و)‪ (b‬در ﺗﺼﻮﻳﺮﻫﺎي ‪ (c)6.13‬و)‪ (d‬ﺑﻪ ﺗﺮﺗﻴﺐ ﻧﺸﺎن داده ﺷﺪه‬

‫اﺳﺖ‪ .‬ﻫﺮ دو ﺗﺼﻮﻳﺮ ﺑﺮاي ﻧﻤﺎﻳﺶ ﺑﻬﺘﺮ ﺧﻄﺎﻫﺎ ﻣﻘﻴﺎس ﺑﻨﺪي ﺷﺪهاﻧﺪ‪.‬‬

‫ﺧﻄﺎﻫﺎي ‪ rms‬ﻣﻄﺎﺑﻖ ﺑﺎ آﻧﻬﺎ ﺑﻪ ﺗﺮﺗﻴﺐ ‪ 2.5‬و ‪ 4.4‬در ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ﻫﺴﺘﻨﺪ‪.‬‬

‫ﺗﺎﺛﻴﺮ اﻳﻦ ﺧﻄﺎﻫﺎ ﺑﺮ ﻛﻴﻔﻴﺖ ﺗﺼﻮﻳﺮ در ﺗﺼﻮﻳﺮﻫﺎي ﺑﺰرﮔﻨﻤﺎﻳﻲ ﺷﺪه ‪ (e)6.13‬و )‪ (f‬ﺑﻪ ﺧﻮﺑﻲ ﻣﺸﻬﻮد اﺳﺖ‪.‬‬

‫اﻳﻦ ﺗﺼﻮﻳﺮﻫﺎ ﺑﻪ ﺗﺮﺗﻴﺐ ﻗﺴﻤﺘﻬﺎي ﺑﺰرگ ﺷﺪه ﻋﻜﺴﻬﺎي ‪ (a)6.13‬و )‪ (b‬ﻫﺴﺘﻨﺪ و ﺑﻬﺘﺮ ﻣﻲﺗﻮان اﺧﺘﻼﻓﻬﺎي ﻇﺮﻳﻒ ﺑﻴﻦ ﺗﺼﻮﻳﺮﻫﺎي ﺑﺎزﺳﺎزي‬

‫ﺷﺪه را ارزﻳﺎﺑﻲ ﻛﺮد‪ .‬ﺗﺼﻮﻳﺮ اﺻﻠﻲ ﺑﺰرگ ﺷﺪه در ﺗﺼﻮﻳﺮ ‪ (b)6.4‬دﻳﺪه ﻣﻲﺷﻮد‪.‬‬

‫ﺑﻪ اﺑﺰار ﻗﻄﻌﻪﺑﻨﺪي ﻛﻪ در ﺗﺼﻮﻳﺮﻫﺎي ﺑﺰرگ ﺷﺪه دﻳﺪه ﻣﻲﺷﻮد ﺗﻮﺟﻪ ﻛﻨﻴﺪ‪.‬‬

‫ﺗﺼﻮﻳﺮﻫﺎي ﻋﻜﺲ ‪ 6.13‬و ﻧﺘﺎﻳﺞ ﻓﻮق ﺑﺎ ﻓﺮﻣﺎﻧﻬﺎي زﻳﺮ ﺑﻪ دﺳﺖ آﻣﺪه اﺳﺖ‪:‬‬

‫;)'‪>> f = imread(Tracy.tif‬‬
‫;)‪>> c1 = im2jpeg(f‬‬
‫;)‪>> f1 = jpeg2im(c1‬‬
‫)‪>> imratio(f, c1‬‬
‫= ‪ans‬‬
‫‪18.2450‬‬
‫)‪>> compare(f, f1, 3‬‬
‫= ‪ans‬‬
‫‪2.4675‬‬
‫;)‪>> c4 = im2jpeg(f, 4‬‬
‫;)‪>> f4 = jpeg2im(c4‬‬
‫)‪>> imratio(f, c4‬‬
‫= ‪ans‬‬
‫‪41.7826‬‬
‫)‪>> compare(f, f4, 3‬‬
‫= ‪ans‬‬
‫‪4.4184‬‬

‫‪43‬‬
‫ﺗﺼﻮﻳﺮ ‪ :6.13‬ﺳﺘﻮن ﭼﭗ ﺳﺎﺧﺖ ﺗﺼﻮﻳﺮ ﺗﻘﺮﻳﺒﻲ ﻋﻜﺲ ‪ 6.4‬ﺑﺎ اﺳﺘﻔﺎده از ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ و آراﻳﻪ ﻫﻨﺠﺎرﺳﺎزي ﺗﺼﻮﻳﺮ ﺳﻤﺖ راﺳﺖ‪:‬‬

‫ﻛﺴﺐ ﻫﻤﺎن ﻧﺘﺎﻳﺞ ﺑﺎ اﺳﺘﻔﺎده از آراﻳﻪ ﻫﻨﺠﺎرﺳﺎزي ﻛﻪ ﺑﻪ ﻣﻘﻴﺎس ‪ 4‬درآﻣﺪه اﺳﺖ‪.‬‬

‫‪44‬‬
‫اﻳﻦ ﻧﺘﺎﻳﺞ ﺑﺎ ﻧﺘﺎﻳﺞ ﺑﻪ دﺳﺖ آﻣﺪه در ﻣﺤﻴﻂ رﻣﺰﮔﺬاري ﻣﺒﻨﺎي ‪ jpeg‬ﺗﻔﺎوت دارد زﻳﺮا ‪ im2jpeg‬ﻣﺤﺼﻮﻟﻲ اﻳﺠﺎد ﻣﻲﻛﻨﺪ ﻛﻪ ﺷﺒﻴﻪ ﺑﻪ‬

‫اﺳﺘﺎﻧﺪارد ‪ jpeg‬ﺑﺎ رﻣﺰﮔﺬاري ﻫﺎﻓﻤﻦ اﺳﺖ‪ 2 .‬ﺗﻔﺎوت ﻋﻤﺪه وﺟﻮد دارد‪:‬‬

‫)‪ (1‬ﻛﻠﻴﻪ دﻓﻌﺎت اﺟﺮاي ﺻﻔﺮﻫﺎي ﺿﺮﻳﺐ در ﺣﺎﻟﺖ اﺳﺘﺎﻧﺪارد داراي رﻣﺰﮔﺬاري ﻫﺎﻓﻤﻦ ﻫﺴﺘﻨﺪ در ﺣﺎﻟﻲ ﻛﻪ ‪ im2jpeg‬ﻓﻘﻂ اﺟﺮاي آﺧﺮ ﻫﺮ‬

‫ﻗﻄﻌﻪ را رﻣﺰﮔﺬاري ﻣﻲﻛﻨﺪ‪.‬‬

‫)‪ (2‬رﻣﺰﮔﺬاري و رﻣﺰﮔﺸﺎﻳﻲ ﺣﺎﻟﺖ اﺳﺘﺎﻧﺪارد ﺑﺮ اﺳﺎس رﻣﺰ ﭘﻴﺶ ﻓﺮض ﻫﺎﻓﻤﻦ اﺳﺖ در ﺣﺎﻟﻲ ﻛﻪ ‪ im2jpeg‬اﻃﻼﻋﺎت ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ﺑﺎزﺳﺎزي‬

‫ﺗﺼﻮﻳﺮ ﺑﺎ ﻛﺪ ﻫﺎﻓﻤﻦ را در ﻣﺒﻨﺎي ﺗﺼﻮﻳﺮ ﻗﺮار ﻣﻲدﻫﺪ‪ .‬ﻧﺴﺒﺖ ﻓﺸﺮدهﺳﺎزي ﺑﺎ اﺳﺘﻔﺎده از اﻳﻦ اﺳﺘﺎﻧﺪارد ‪ 2‬ﺑﺮاﺑﺮ ﻣﻲﺷﻮد‪.‬‬

‫‪ .6.5.2‬ﺑﺮرﺳﻲ ﭘﺴﻮﻧﺪ ‪jpeg2000‬‬

‫ﭘﺴﻮﻧﺪ ﻓﻮق ﻫﻤﭽﻮن ﭘﺴﻮﻧﺪ ‪ jpeg‬ﻣﻌﻤﻮﻟﻲ ﺑﺮ اﺳﺎس اﻳﻦ اﺳﺘﺪﻻل اﺳﺖ ﻛﻪ ﺿﺮاﻳﺐ ﺗﺒﺪﻳﻞ ﻛﻪ ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي را ارﺗﺒﺎطزداﻳﻲ ﻣﻲﻛﻨﻨﺪ ﻣﻮﺛﺮﺗﺮ‬

‫از ﻋﻨﺎﺻﺮ اﺻﻠﻲ ﻗﺎﺑﻞ رﻣﺰﮔﺬاري ﻫﺴﺘﻨﺪ‪ .‬اﮔﺮ ﺗﺎﺑﻌﻬﺎي ﻣﺒﻨﺎي ﺗﺒﺪﻳﻞ ﻛﻪ اﻣﻮاج ﻛﻮﭼﻜﻲ در ‪ jpeg2000‬ﻫﺴﺘﻨﺪ اﻛﺜﺮ اﻃﻼﻋﺎت ﺗﺼﻮﻳﺮي ﻣﻬﻢ را‬

‫ﺑﻪ ﺗﻌﺪاد ﻣﺤﺪودي از ﺿﺮاﻳﺐ ﻓﺸﺮده ﻛﻨﻨﺪ ﻣﺎﺑﻘﻲ ﺿﺮاﻳﺐ ﺑﺎ داﻧﻪﻫﺎي درﺷﺖ ﻛﻤﻲ ﺳﺎزي ﻣﻲﺷﻮﻧﺪ و ﺑﺎ اﻧﺪﻛﻲ ﺗﺤﺮﻳﻒ ﺗﺼﻮﻳﺮ ﺑﻪ ﺻﻔﺮ ﺑﺮﻳﺪه‬

‫ﻣﻲﺷﻮﻧﺪ‪.‬‬

‫ﻳﻚ ﺳﻴﺴﺘﻢ رﻣﺰﮔﺬاري ﺳﺎده ﺷﺪه ‪ jpeg2000‬در ﺗﺼﻮﻳﺮ ‪ 6.14‬ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‪ .‬اوﻟﻴﻦ ﻣﺮﺣﻠﻪ رﻣﺰﮔﺬاري اﻧﺘﻘﺎل ﻋﻨﺎﺻﺮ ﺗﺼﻮﻳﺮي ﺑﺎ ﻛﻢ‬

‫ﻛﺮدن ‪2m-1‬اﺳﺖ ﻛﻪ در اﻳﻨﺠﺎ ‪ 2m‬ﺗﻌﺪاد ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي)‪ (gray_level‬ﺗﺼﻮﻳﺮ اﺳﺖ‪ .‬ﺗﺒﺪﻳﻞ ﻣﺘﻤﺎﻳﺰ ﺗﻚ ﺑﻌﺪي ردﻳﻔﻬﺎ و ﺳﺘﻮﻧﻬﺎي ﺗﺼﻮﻳﺮ‬

‫ﻗﺎﺑﻞ ﻣﺤﺎﺳﺒﻪ اﺳﺖ‪.‬‬

‫ﺗﺒﺪﻳﻞ اﺳﺘﻔﺎده ﺷﺪه در ﻓﺸﺮدهﺳﺎزي ﺑﺪون ﺧﻄﺎ دوﻣﺘﻌﺎﻣﺪي اﺳﺖ‪ .‬ﻛﻪ ﻣﻘﻴﺎس ﺑﻨﺪي ﺿﺮاﻳﺐ ‪ 3-5‬و ﺑﺮداري از اﻣﻮاج ﻛﻮﭼﻚ دارد‪ .‬در‬

‫ﺑﺮﻧﺎﻣﻪﻫﺎﻳﻲ ﻛﻪ اﺗﻼف اﻃﻼﻋﺎت دارﻳﻢ از ﺑﺮداري ﺑﺎ ﻣﻘﻴﺎس ﺑﻨﺪي ﺿﺮﻳﺐ ‪ 7-9‬اﺳﺘﻔﺎده ﻣﻲﺷﻮد )ﺑﻪ ﺗﺎﺑﻊ ‪ wavefilter‬ﻓﺼﻞ ‪ 7‬ﻣﺮاﺟﻌﻪ ﻛﻨﻴﺪ(‪ .‬ﺑﻪ‬

‫‪45‬‬
‫ﻫﺮ ﺣﺎل ﺗﺠﺰﻳﻪ اوﻟﻴﻪ ﻣﻨﺠﺮ ﺑﻪ اﻳﺠﺎد ‪ 4‬ﻣﻘﻮﻟﻪ ﻓﺮﻋﻲ ﻣﻲﺷﻮد‪ :‬ﺷﺒﻴﻪ ﺳﺎزي ﺗﺼﻮﻳﺮ ﺑﺎ ﺗﻔﻜﻴﻚ ﭘﺬﻳﺮي ﭘﺎﻳﻴﻦ‪ ،‬و ﺧﺼﻮﺻﻴﺎت ﻓﺮﻛﺎﻧﺲ اﻓﻘﻲ‪ ،‬ﻋﻤﻮدي‬

‫و ارﻳﺐ ﺗﺼﻮﻳﺮ‪.‬‬

‫اﮔﺮ ﻓﺮاﻳﻨﺪ ﺗﺠﺰﻳﻪ ‪ NL‬دﻓﻌﻪ ﺗﻜﺮار ﺷﻮد‪ ،‬و ﺗﻜﺮارﻫﺎي ﺑﻌﺪي ﻣﺤﺪود ﺑﻪ ﺿﺮﻳﺒﻬﺎي ﺗﺠﺰﻳﻪﮔﺮ ﻗﺒﻞ ﺑﺎﺷﺪ ﻳﻚ ﺗﺒﺪﻳﻞ ﺑﺎ ﻣﻘﻴﺎس ‪ NL‬ﺗﻮﻟﻴﺪ ﻣﻲﺷﻮد‪.‬‬

‫ﻣﻘﻴﺎﺳﻬﺎي ﻣﺠﺎور ﺑﺎ ﺗﻮان ‪ 2‬ﻣﺮﺗﺒﻂ ﻣﻲﺷﻮﻧﺪ و ﭘﺎﻳﻴﻨﺘﺮﻳﻦ ﻣﻘﻴﺎس ﻧﻮع ﺗﻌﺮﻳﻒ ﺷﺪه ﺗﺼﻮﻳﺮ اﺻﻠﻲ را دارد‪ .‬ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﺗﺼﻮﻳﺮ ‪ 6.15‬ﺣﺪس‬

‫زده ﻣﻲﺷﻮد‪ ،‬ﻧﺸﺎﻧﻪﮔﺬاري اﺳﺘﺎﻧﺪارد در ﻣﻮرد ‪ NL =2‬ﺧﻼﺻﻪ ﺷﺪه اﺳﺖ و ﻳﻚ ﻣﻘﻴﺎس ﺗﺒﺪﻳﻞ ﻋﻤﻮﻣﻲ ‪ NL‬و‪ 3 NL +1‬واﺣﺪ ﻓﺮﻋﻲ دارد ﻛﻪ‬

‫ﺿﺮاﻳﺐ آن ﺑﺎ ‪ ab‬ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‪ .‬در اﻳﻦ اﺳﺘﺎﻧﺪارد ﺗﻌﺪاد ﻣﻘﻴﺎسﻫﺎي ﻣﺤﺎﺳﺒﻪ ﺷﺪه ﻣﺸﺨﺺ ﻧﻤﻲﺷﻮد‪.‬‬

‫ﭘﺲ از ﻣﺤﺎﺳﺒﻪ ﺗﺒﺪﻳﻞ ﻣﻮﺟﻲ ﻣﻘﻴﺎس ‪ NL‬ﻛﻞ ﺗﻌﺪاد ﺿﺮاﻳﺐ ﺗﺒﺪﻳﻞ ﻣﻌﺎدل ﺗﻌﺪاد ﻧﻤﻮﻧﻪﻫﺎي ﺗﺼﻮﻳﺮ اﺻﻠﻲ اﺳﺖ وﻟﻲ اﻃﻼﻋﺎت ﺗﺼﻮﻳﺮي اﺻﻠﻲ‬

‫در ﭼﻨﺪ ﺿﺮﻳﺐ ﻣﺘﻤﺮﻛﺰ ﺷﺪه اﺳﺖ‪ .‬ﺑﺮاي ﻛﺎﻫﺶ ﺗﻌﺪاد ﺑﻴﺘﻬﺎي ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ﻧﻤﺎﻳﺶ آﻧﻬﺎ ﺿﺮﻳﺐ )‪ ab(u, v‬ﺑﺎﻧﺪ ﻓﺮﻋﻲ‪ b‬ﺑﻪ ﻣﻘﺪار )‪ qb(u, v‬ﺑﺎ‬

‫اﺳﺘﻔﺎده از راﺑﻄﻪ زﻳﺮ ﻛﻤﻲ ﺳﺎزي ﻣﻲﺷﻮد‪:‬‬

‫؟‬

‫در اﻳﻨﺠﺎ ﻋﻤﻠﮕﺮﻫﺎي "‪ "sign‬و "‪ "floor‬ﻫﻤﭽﻮن ﺗﺎﺑﻌﻬﺎي ﻫﻢ اﺳﻢ ﻧﺮم اﻓﺰار ‪ MATLAB‬ﻫﺴﺘﻨﺪ‪ .‬در اﻳﻦ ﻣﺮﺣﻠﻪ ﻛﻤﻲ ﺳﺎزي ‪،‬اﻧﺪازه ‪∆b‬‬

‫ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ‪:‬‬

‫؟‬

‫‪ Rb‬ﺣﻴﻄﻪ اﺳﻤﻲ ﭘﻮﻳﺎي ﺑﺎﻧﺪ ﻓﺮﻋﻲ ‪ b‬اﺳﺖ و‪ εb , µ b‬ﺗﻌﺪاد ﺑﻴﺘﻬﺎي ﺗﺨﺼﻴﺺ داده ﺷﺪه ﺑﻪ ﻧﻤﺎ و ﺟﺰء اﻋﺸﺎري ﻟﮕﺎرﻳﺘﻢ ﺿﺮاﻳﺐ ﺑﺎﻧﺪ ﻓﺮﻋﻲ‬

‫ﻫﺴﺘﻨﺪ‪ .‬ﺣﻴﻄﻪ ﭘﻮﻳﺎي ﺑﺎﻧﺪ ﻓﺮﻋﻲ‪ b‬ﻣﺠﻤﻮع ﺑﻴﺘﻬﺎي ﻣﻮرد ﻧﻴﺎز ﺑﺮاي ﻧﻤﺎﻳﺶ ﺗﺼﻮﻳﺮ اﺻﻠﻲ و ﺗﺤﻠﻴﻞ ﺑﺎﻧﺪ ﻓﺮﻋﻲ ‪ b‬اﺳﺖ‪.‬‬

‫‪46‬‬
 ‫ﺗﺤﻠﻴﻞ ﺑﻴﺘﻬﺎي ﺑﺎﻧﺪ ﻓﺮﻋﻲ ﻣﻄﺎﺑﻖ ﺑﺎ اﻟﮕﻮي ﺳﺎده ﺗﺼﻮﻳﺮ ‪ 6.15‬اﺳﺖ‪ .‬ﻣﺜﻼً در ﺑﺎﻧﺪ ﻓﺮﻋﻲ ‪ b=1HH‬دو ﺗﺤﻠﻴﻞ ﺑﻴﺘﻲ وﺟﻮد دارد‪.‬‬

‫ﺑﺮاي ﻓﺸﺮدهﺳﺎزي ﺑﺪون ﺧﻄﺎ ‪ µ b =0‬و‪ Rb=εb‬ﻛﻪ در ﻧﺘﻴﺠﻪ ‪ ∆ b =1‬اﺳﺖ‪ .‬در ﻓﺸﺮدهﺳﺎزيﻫﺎي ﺑﺮﮔﺸﺖﻧﺎﭘﺬﻳﺮ ﻫﻴﭻ ﻣﺮﺣﻠﻪ ﻛﻤﻲ ﺳﺎزي‬

‫ﺧﺎﺻﻲ ﻣﺸﺨﺺ ﻧﻤﻲﺷﻮد‪ .‬در ﻋﻮض ﺗﻌﺪاد ﺑﻴﺘﻬﺎي ﺟﺰء اﻋﺸﺎري ﻟﮕﺎرﻳﺘﻢ و ﻧﻤﺎ ﺑﺮ اﺳﺎس ﺑﺎﻧﺪ ﻓﺮﻋﻲ ﺑﻪ ﻧﺎم ﻛﻤﻲ ﺳﺎزي ﻋﻠﻨﻲ در اﺧﺘﻴﺎر رﻣﺰﮔﺸﺎ‬

‫ﻗﺮار داده ﻣﻲﺷﻮد و ﻳﺎ ﻓﻘﻂ ﺑﺮ اﺳﺎس ﺑﺎﻧﺪ ﻓﺮﻋﻲ ‪ NLLL‬ﺑﺎ ﻋﻨﻮان ﻛﻤﻲ ﺳﺎزي ﻧﻬﻔﺘﻪ )‪(implicit quantization‬اﻧﺠﺎم ﻣﻲﺷﻮد‪ .‬در ﻣﻮرد‬

‫دوم‪ ،‬ﻣﺎﺑﻘﻲ ﺑﺎﻧﺪﻫﺎي ﻓﺮﻋﻲ ﺑﺎ اﺳﺘﻔﺎده از ﭘﺎراﻣﺘﺮﻫﺎي ﺑﺎﻧﺪ ﻓﺮﻋﻲ ‪ NLLL‬ﻛﻤﻲ ﺳﺎزي ﻣﻲﺷﻮﻧﺪ‪ .‬ﻓﺮض ﻛﻨﻴﺪ ‪ , µ0 ε 0‬ﺗﻌﺪاد ﺑﻴﺘﻬﺎي ﺗﺨﺼﻴﺺ‬

‫داده ﺷﺪه ﺑﻪ ﺑﺎﻧﺪ ﻓﺮﻋﻲ ‪ NLLL‬ﻫﺴﺘﻨﺪ‪ .‬ﭘﺎراﻣﺘﺮﻫﺎي درون ﻳﺎﺑﻲ ﺷﺪه ﺑﺎﻧﺪ ﻓﺮﻋﻲ ب ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ‪:‬‬

‫؟‬

‫در اﻳﻨﺠﺎ ‪ nsdb‬ﺗﻌﺪاد ﺳﻄﻮح ﺗﺠﺰﻳﻪ ﺑﺎﻧﺪ ﻓﺮﻋﻲ از ﺗﺼﻮﻳﺮ اﺻﻠﻲ ﻧﺴﺒﺖ ﺑﻪ ﺑﺎﻧﺪ ﻓﺮﻋﻲ ‪ b‬اﺳﺖ‪.‬‬

‫در ﻣﺮﺣﻠﻪ ﻧﻬﺎﻳﻲ رﻣﺰﮔﺬاري ﺿﺮاﻳﺐ ﻛﻤﻲ ﺳﺎزي ﺷﺪه ﺑﺮ اﺳﺎس اﺻﻮل رﻳﺎﺿﻲ رﻣﺰﮔﺬاري ﻣﻲﺷﻮﻧﺪ‪ .‬ﮔﺮﭼﻪ رﻣﺰﮔﺬاري رﻳﺎﺿﻲ ) ‪aritmetic‬‬

‫‪ (coding‬در اﻳﻦ ﻓﺼﻞ ﺑﺮرﺳﻲ ﻧﺸﺪه اﺳﺖ وﻟﻲ ﻳﻚ روش رﻣﺰﮔﺬاري ﺑﺎ ﻃﻮل ﻣﺘﻐﻴﺮ اﺳﺖ ﻛﻪ ﻫﻤﭽﻮن رﻣﺰﮔﺬاري ﻫﺎﻓﻤﻦ ﺑﺮاي ﻛﺎﻫﺶ اﻓﺰوﻧﮕﻲ‬

‫رﻣﺰﮔﺬاري ﻃﺮاﺣﻲ ﺷﺪه اﺳﺖ‪.‬‬

‫ﺗﺎﺑﻊ ﺳﻔﺎرﺷﻲ ‪ im2jpeg2k‬ﻓﺮاﻳﻨﺪي ﺷﺒﻴﻪ ﺑﻪ رﻣﺰﮔﺬاري ‪ jpeg2000‬در ﺗﺼﻮﻳﺮ ‪ (a)6.14‬دارد‪ .‬ﺗﻨﻬﺎ اﺳﺘﺜﻨﺎ رﻣﺰﮔﺬاري ﻧﻤﺎدﻳﻦ رﻳﺎﺿﻲ اﺳﺖ‪.‬‬

‫ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﻓﻬﺮﺳﺖ زﻳﺮ دﻳﺪه ﻣﻲﺷﻮد رﻣﺰﮔﺬاري ﻫﺎﻓﻤﻦ ﻛﻪ ﺑﺎ رﻣﺰﮔﺬاري ﺻﻔﺮ ﺗﻘﻮﻳﺖ ﺷﺪه ﺟﺎﻳﮕﺰﻳﻦ ﺣﺎﻟﺖ ﺳﺎده ﺷﺪه اﺳﺖ‪.‬‬
‫)‪function y = im2jpeg2k(x, n, q‬‬
‫‪%IM2JPEG Compresses an image using a 2000 approximation.‬‬
‫‪%‬‬ ‫‪Y = IM2JPEG2K(X, N, Q) Compresses image X using an N-scale JPEG‬‬
‫‪%‬‬ ‫‪2k wavelet transform, implicit or explicit coefficient‬‬
‫‪%‬‬ ‫‪quantization, and Huffman symbol coding augmented by zero‬‬
‫‪%‬‬ ‫‪run-length coding. If quantization vector Q contains two‬‬
‫‪%‬‬ ‫‪elements, they are assumed to be implicit quantization‬‬
‫‪%‬‬ ‫‪parameters; else, it is assumed to contain explicit subband step‬‬
‫‪%‬‬ ‫‪size. Y is an encoding structure containing Huffman-encoded‬‬
‫‪%‬‬ ‫‪data and additional parameters needed by JPEG2K2IM for decoding.‬‬
‫‪%‬‬
‫‪%‬‬ ‫‪See also JPEG2K2IM.‬‬
‫‪global RUNS‬‬
‫;))‪error(nargchk(3, 3, nargin‬‬ ‫‪% Check input arguments‬‬
‫)'‪if nargin(x) ~= 2 | ~isreal(x) | ~isnumeric(x) | ~isa(x, 'uint8‬‬
‫;)'‪error('The input must be a UINT8 image.‬‬
‫‪end‬‬
‫‪if length(q) ~= 2 & length(q) ~= 3 * n + 1‬‬
‫;)'‪error('The quantization step size vector is bad.‬‬
‫‪end‬‬
‫‪% Level shift the input and compute its wavelet transform.‬‬
‫;‪x = double(x) – 128‬‬
‫;)'‪[c, s] = wavefast(x, n, 'jpeg.7‬‬
‫‪% Quantize the wavelet coefficients.‬‬
‫;)‪q = stepsize(n, q‬‬
‫;)‪sgn = sign(c‬‬ ‫;‪sgn(find(sgn == 0) = 1‬‬ ‫;)‪c = abs(c‬‬

‫‪47‬‬
for k = 1:n
qi = 3* k – 2;
c = wavepaste('h', c, s, k, wavecopy('h', c, s, k) / q(qi));
c = wavepaste('v', c, s, k, wavecopy('v', c, s, k) / q(qi+1));
c = wavepaste('d', c, s, k, wavecopy('d', c, s, k) / q(qi+2));
end
c = wavepaste('a', c, s, k, wavecopy('a', c, s, k) / q(qi+3));
c = floor(c);

% Run-length code zero runs of more 10. Begin by creating

% a special code for 0 runs ('zrc') and end-of-code ('eoc') and
% making a run-length table.
Zrc = min(c(:)) – 1; eoc = zrc – 1; RUNS = [65535]

% Find the run transition points: 'plus' contains the index of the
% start of a zero run; the corresponding 'minus' is its end + 1.
z = c == 0; z = z – [0 z(1:end – 1)];
plus = find(z == 1); minus = find(z == -1);

% Remove any terminating zero run form 'c'.

if length(plus) ~= length(minus)
c(plus(end):end) = []; c = [c eoc];
end

% Remove all other zero runs (based on 'plus' and 'minus') from 'c'.
for i = length(minus):-1:1
run = minus(i) – plus(i);
if run > 0
ovrflo = floor(run / 65535); run = run – ovrflo * 65535;
c = [c(1:plus(i) – 1) repmat([zrc 1], 1, ovrflo) zrc …
runcode(run) c(minus(i):end)];
end
end

% Huffman encode and add misc. information for decoding.

y.runs = uint16(RUNS);
y.s = uint16(s(:));
y.zrc = uint16(-zrc);
y.q = uint16(100 * q');
y.n = uint16(n);
y.huffman = mat2huff(c);

%----------------------------------------------------------------------------------
----%
function y = runcode(x)
% Find a zero run in the run-length table. If not found, create a
% new entry in the table. Return the index of the run.
global RUNS
y = find(RUNS == x);
if length(y) ~= 1
RUNS = [RUNS; x];
y = length(RUNS);
end

%----------------------------------------------------------------------------------
----%
function q = stepsize(n, p)
% Create a subband quantization array of step ordered by
% decomposition (first to last) and subband (horizontal, vertical),

48
% diagonal, and for final decomposition the approximation subband).
if length(p) == 2 % Implicit Quantization
q = [ ];
qn = 2 ^ (8 – p(2) + n) * (1 + p(1) / 2 ^ 11);
for k = 1:n
qk = 2 ^ - k * qn;
q = [q (2 * qk) (2 * qk) (4 * qk)];
end
q = [q qk];
else % Explicit Quantization
q = p;
end

q = round(q * 100) / 100; % Round to 1/100th place

if any(100 * q > 65535)
error('The quantizing steps are not UINT16 represent able.');
end
if any(q == 0)
error(A quantizing steps of 0 is not allowed.');
end

‫ ﭘﺲ از رﻣﺰﮔﺸﺎﻳﻲ اﻳﻦ ﺿﺮاﻳﺐ رﻳﺎﺿﻲ ﺑﺎﻧﺪﻫﺎي ﻓﺮﻋﻲ ﺗﺼﻮﻳﺮ اﺻﻠﻲ‬.‫ ﺻﺮﻓﺎً روﻧﺪ ﻋﻤﻠﻴﺎت ﻓﻮق را ﻣﻌﻜﻮس ﻣﻲﻛﻨﻨﺪ‬jpeg2000 ‫رﻣﺰﮔﺸﺎﻫﺎي‬

‫ را ﺑﺮاي ﺑﺎﻧﺪﻫﺎي ﻓﺮﻋﻲ ﺧﺎﺻﻲ رﻣﺰﮔﺬاري ﻣﻲﻛﻨﺪ وﻟﻲ ﻛﺎرﺑﺮ ﻣﻤﻜﻦ اﺳﺖ ﺑﺎ‬Mb ‫ ﮔﺮﭼﻪ اﻳﻦ رﻣﺰﮔﺬار ﺑﻴﺘﻬﺎي‬.‫ﻣﻨﺘﺨﺐ ﻛﺎرﺑﺮ ﺑﺎزﺳﺎزي ﻣﻲﺷﻮﻧﺪ‬

2 Mb- . ∆b ‫ ﺑﺮاي اﻳﻦ ﻛﺎر ﺿﺮاﻳﺐ ﺑﺎ اﺳﺘﻔﺎده از ﻣﺮﺣﻠﻪ‬.‫ ﺧﺎﺻﻲ ﺑﮕﻴﺮد‬Nb ‫ﺗﻮﺟﻪ ﺑﻪ ﺟﺮﻳﺎﻧﻬﺎي ﺗﻌﺒﻴﻪ ﺷﺪه ﻓﻘﻂ ﺗﺼﻤﻴﻢ ﺑﻪ رﻣﺰﮔﺸﺎﻳﻲ ﺑﻴﺘﻬﺎي‬

.‫ ﺑﻴﺘﻬﺎي رﻣﺰﮔﺸﺎﻳﻲ ﻧﺸﺪه ﺻﻔﺮ ﻣﻲﺷﻮﻧﺪ و ﺿﺮاﻳﺐ ﺣﺎﺻﻞ از آن ﺑﺎ اﺳﺘﻔﺎده از راﺑﻄﻪ زﻳﺮ ﻫﻨﺠﺎرزداﻳﻲ ﻣﻲﺷﻮﻧﺪ‬.‫ﻛﻤﻲ ﺳﺎزي ﻣﻲﺷﻮﻧﺪ‬Nb

(q b (u , v) + 2 M b − N b (u , v ) ).∆ b q b (u , v) > 0


Rqb (u , v ) = (q b (u , v ) − 2 M b − N b (u , v ) ).∆ b q b (u , v) < 0
 0 q b (u , v) = 0

‫ ﺗﻌﺪاد ﺑﻴﺘﻬﺎي رﻣﺰﮔﺸﺎﻳﻲ ﺷﺪه‬Nb(u, v) ‫ ﻳﻚ ﺿﺮﻳﺐ ﺗﺒﺪﻳﻞ ﻫﻨﺠﺎرزداﻳﻲ ﺷﺪه اﺳﺖ و‬Rqb(u, v) ‫در اﻳﻨﺠﺎ‬

‫ ﺳﭙﺲ ﺿﺮاﻳﺐ ﻫﻨﺠﺎرزداﻳﻲ ﺷﺪه ﺑﻪ ﺻﻮرت ﻣﻌﻜﻮس ﺗﺒﺪﻳﻞ ﻣﻲﺷﻮﻧﺪ و ﺟﺎﺑﺠﺎ ﻣﻴﺸﻮﻧﺪ ﺗﺎ ﻣﺤﺼﻮﻟﻲ ﺷﺒﻴﻪ ﺑﻪ ﺗﺼﻮﻳﺮ اﺻﻠﻲ‬.‫ اﺳﺖ‬qb(u, v)

.‫ را ﻣﻌﻜﻮس ﻣﻲﻛﻨﺪ‬im2jpeg2k ‫ ﺷﺒﻴﻪ اﻳﻦ روﻧﺪ را اﻳﺠﺎد ﻣﻲﻛﻨﺪ و ﻓﺸﺮدهﺳﺎزي‬jpeg2k2im ‫ ﺗﺎﺑﻊ ﺳﻔﺎرﺷﻲ‬.‫ﺣﺎﺻﻞ ﺷﻮد‬
function x = jpeg2k2im(y)
%JPEG2K2IM Decoded an IM2JPEG2K compressed image.
% X = JPEG2K2IM(Y) decoded compresses image Y, reconstructing an
% structure returned by IM2JPEG2K.
%
% See also IM2JPEG2K.
error(nargchk(1, 1, nargin)); % Check input arguments
% Get decoding parameters: scale, quantization vector, run-length
% table size, zero run code, end-of-data code, wavelet bookkeeping
% array, and run-length table.
n = double(y.n);
q = double(y.q) / 100;
runs = double(y.runs);
rlen = length(runs);

49
‫;)‪zrc = -double(y.zrc‬‬
‫;‪eoc = zrc – 1‬‬
‫;)‪s = reshape(s, n + 2, 2‬‬

‫‪% Compute the size of the wavelet transform.‬‬

‫‪Cl = prod(1, :)):‬‬
‫‪for i = 2:n + 1‬‬
‫;))‪cl = cl + 3 * prod(s(i, :‬‬
‫‪end‬‬

‫‪% Perform Huffman decoding followed by zero run decoding.‬‬

‫;)‪r = huff2mat(y.huffamn‬‬
‫;][ = ‪c‬‬ ‫;)‪zi = find(r == zrc‬‬ ‫;‪i = 1‬‬
‫)‪for j = 1:length(zi‬‬
‫;])))‪c = [c r(i:zi(j) – 1) zeros(1, runs(r(zi(j) + 1‬‬
‫‪end‬‬
‫;)‪zi = find(r == eoc‬‬ ‫‪% Undo terminating zero run‬‬
‫‪if length(zi) == 1‬‬ ‫‪% or last non-zero run.‬‬
‫;])‪c = [c r(i:zi – 1‬‬
‫;]))‪c = [c zeros(1, c1 – length‬‬
‫‪else‬‬
‫;])‪c = [c r(i:end‬‬
‫‪end‬‬

‫‪%Denormalize the coefficients.‬‬

‫;)‪c = c + (c > 0) – (c < 0‬‬
‫‪for k = 1:n‬‬
‫;‪qi = 3 * k – 2‬‬
‫‪c = wavepaste('h', c, s, k, wavecopy('h',‬‬ ‫;))‪c, s, k) / q(qi‬‬
‫‪c = wavepaste('v', c, s, k, wavecopy('v',‬‬ ‫;))‪c, s, k) / q(qi+1‬‬
‫‪c = wavepaste('d', c, s, k, wavecopy('d',‬‬ ‫;))‪c, s, k) / q(qi+2‬‬
‫‪end‬‬
‫‪c = wavepaste('a', c, s, k, wavecopy('a', c, s,‬‬ ‫;))‪k) / q(qi+3‬‬

‫‪% Compute the inverse wavelet transform and level shift.‬‬

‫;)‪x = waveback(c, s, 'jpeg9.7', n‬‬
‫;)‪x = uint8(x + 128‬‬

‫اﺧﺘﻼف اﺻﻠﻲ ﺑﻴﻦ ﺳﻴﺴﺘﻢ ﻣﺒﺘﻨﻲ ﺑﺮ اﻣﻮاج ﻛﻮﭼﻚ در ﺗﺼﻮﻳﺮ ‪ 6.14‬و ﺳﻴﺴﺘﻢ ‪ jpeg‬ﻣﺒﺘﻨﻲ ﺑﺮ ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ در ﺗﺼﻮﻳﺮ ‪6.11‬‬

‫ﺣﺬف ﻣﺮاﺣﻞ ﭘﺮدازش ﺗﺼﻮﻳﺮ ﻓﺮﻋﻲ اﺳﺖ‪ .‬از آﻧﺠﺎﺋﻲ ﻛﻪ ﺗﺒﺪﻳﻠﻬﺎي اﻣﻮاج ﻛﻮﭼﻚ از ﻧﻈﺮ ﻣﺤﺎﺳﺒﺎﺗﻲ ﻣﻮﺛﺮ و ذاﺗﺎٌ ﻣﻮﺿﻌﻲ ﻫﺴﺘﻨﺪ )ﻳﻌﻨﻲ ﻋﻤﻠﻜﺮد‬

‫اﺳﺎﺳﻲ آﻧﻬﺎ ﻣﺪت ﻣﺤﺪود دارد( ﻧﻴﺎزي ﺑﻪ ﺗﻘﺴﻴﻢ ﺗﺼﻮﻳﺮ ﺑﻪ ﻗﻄﻌﺎت ﻛﻮﭼﻜﺘﺮ ﻧﻴﺴﺖ‪ .‬ﻫﻤﺎن ﻃﻮر ﻛﻪ در ﻣﺜﺎل زﻳﺮ ﻣﻲﺑﻴﻨﻴﻢ‪ ،‬ﺣﺬف ﻣﺮﺣﻠﻪ ﺗﻘﺴﻴﻢ‬

‫ﺑﺎﻋﺚ ﺣﺬف اﺑﺰار ﻗﻄﻌﻪ ﺑﻨﺪي ﻣﻲﺷﻮد ﻛﻪ در ﻧﺴﺒﺘﻬﺎي ﻓﺸﺮدهﺳﺎزي ﺑﺎﻻ ﺧﺼﻮﺻﻴﺎﺗﻲ ﺷﺒﻴﻪ ﺑﻪ ﺗﺒﺪﻳﻞ ﻛﺴﻴﻨﻮﺳﻲ ﻣﺘﻤﺎﻳﺰ اﻳﺠﺎد‪ DCT‬ﻣﻲﻛﻨﺪ‪.‬‬

‫دو ﻧﻮع ﺷﺒﻴﻪ ﺳﺎزي ﺧﺼﻮﺻﻴﺎت ﺗﺼﻮﻳﺮ ﺗﻚ رﻧﮓ ‪ (a)6.4‬در ﺗﺼﻮﻳﺮ ‪ 6.16‬دﻳﺪه ﻣﻲﺷﻮد‪ .‬ﺗﺼﻮﻳﺮ ‪ (a)6.16‬از رﻣﺰﮔﺬاري ﺑﺎزﺳﺎزي ﺷﺪ ﻛﻪ ﺗﺼﻮﻳﺮ‬

‫اﺻﻠﻲ را ﺑﻪ ﻧﺴﺒﺖ ‪ 42‬ﺑﻪ ‪ 1‬ﻓﺸﺮده ﻛﺮده ﺑﻮد‪ .‬ﺗﺼﻮﻳﺮ ‪ (b)6.16‬از رﻣﺰﮔﺬاري ‪ 88:1‬اﻳﺠﺎد ﺷﺪ‪ .‬اﻳﻦ دو ﻧﺘﻴﺠﻪ ﺑﺎ اﺳﺘﻔﺎده از ﺗﺒﺪﻳﻞ ‪ 5‬ﻣﻘﻴﺎﺳﻲ و‬

‫ﻛﻤﻲ ﺳﺎزي ﻧﻬﻔﺘﻪ ﺑﻪ ﺗﺮﺗﻴﺐ ‪µ 0=8‬‬

‫‪ µ 0=8.5‬ﺑﻪ دﺳﺖ آﻣﺪ‪ .‬از آﻧﺠﺎﺋﻲ ﻛﻪ ‪ im2jpeg2k‬ﻓﻘﻂ رﻣﺰﮔﺬاري ﺷﺒﻴﻪ ﺑﻪ ‪jpeg2000‬اﻳﺠﺎد ﻣﻲﻛﻨﺪ‪ ،‬ﻧﺴﺒﺘﻬﺎي ﻓﺸﺮدهﺳﺎزي ﻗﻴﺪ ﺷﺪه‬

‫ﻓﻘﻂ ﺑﺎ ﻧﺴﺒﺘﻬﺎي رﻣﺰﮔﺬاري واﻗﻌﻲ ‪ jpeg2000‬ﺗﻔﺎوت دارﻧﺪ‪ .‬در واﻗﻊ ﻧﺴﺒﺘﻬﺎي واﻗﻌﻲ ‪ 2‬ﺑﺮاﺑﺮ اﻓﺰاﻳﺶ ﻣﻲﻳﺎﺑﺪ‪.‬‬

‫‪50‬‬
‫از آﻧﺠﺎﺋﻲ ﻛﻪ ﻓﺸﺮدهﺳﺎزي ‪ 42:1‬ﻧﺘﺎﻳﺞ در ﺳﺘﻮن ﺳﻤﺖ ﭼﭗ ﺗﺼﻮﻳﺮ ‪ 6.16‬ﻫﻤﺎﻧﻨﺪ ﻓﺸﺮدهﺳﺎزي ﺗﺤﻘﻖ ﻳﺎﻓﺘﻪ در ﺳﺘﻮن ﺳﻤﺖ راﺳﺖ ﺗﺼﻮﻳﺮ‬

‫‪ 6.13‬اﺳﺖ )ﻣﺜﺎل ‪ (6.8‬ﺗﺼﻮﻳﺮﻫﺎي ‪ c ،e.6.16‬از ﻧﻈﺮ ﻛﻴﻔﻲ و ﻛﻤﻲ ﺑﺎ ﻧﺘﺎﻳﺞ ﺗﺒﺪﻳﻞ ﺗﺼﻮﻳﺮﻫﺎي ‪ d ،b 6.13‬و ‪ f‬ﻗﺎﺑﻞ ﻗﻴﺎس ﻫﺴﺘﻨﺪ‪ .‬ﺑﻌﺪ از‬

‫ﻣﻘﺎﻳﺴﻪ اﻳﻦ ﺗﺼﺎوﻳﺮ ﻛﺎﻫﺶ ﭼﺸﻤﮕﻴﺮ ﺧﻄﺎ در ﺗﺼﻮﻳﺮﻫﺎي ‪ jpeg2000‬دﻳﺪه ﻣﻲﺷﻮد‪ .‬در واﻗﻊ ﺧﻄﺎي ‪ rms‬ﻧﺘﺎﻳﺞ ﻣﺒﺘﻨﻲ ﺑﺮ ‪ jpeg2000‬در‬

‫ﺗﺼﻮﻳﺮ ‪ (a).6.16‬در ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ‪ 3.7‬اﺳﺖ ﻛﻪ در ﺗﻘﺎﺑﻞ ﺑﺎ ﻣﻘﺪار ‪ 4.4‬در ﻧﺘﺎﻳﺞ ﺗﺼﻮﻳﺮ ‪ (b)6.13‬اﺳﺖ‪.‬‬

‫ﺑﻪ ﻏﻴﺮ از ﻛﺎﻫﺶ ﺧﻄﺎي ﺑﺎزﺳﺎزي رﻣﺰﮔﺬاري ‪ jpeg2000‬ﻛﻴﻔﻴﺖ ﺗﺼﻮﻳﺮ را ﺑﻪ ﺷﻜﻠﻲ ﺧﺎص ﺑﻬﺒﻮد ﺑﺨﺸﻴﺪه اﺳﺖ‪ .‬اﻳﻦ ﻣﻮﺿﻮع در ﺗﺼﻮﻳﺮ‬

‫‪ (e).6.16‬ﻣﺸﻬﻮد اﺳﺖ‪ .‬ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ اﺑﺰار ﻗﻄﻌﻪ ﺑﻨﺪي ﻛﻪ در ﻧﺘﺎﻳﺞ ﺗﺒﺪﻳﻞ ﺗﺼﻮﻳﺮ‪ (f).6.13‬دﻳﺪه ﻣﻲﺷﺪ دﻳﮕﺮ وﺟﻮد ﻧﺪارد‪.‬‬

‫وﻗﺘﻲ ﺳﻄﺢ ﻓﺸﺮدهﺳﺎزي ﻫﻤﭽﻮن ﺗﺼﻮﻳﺮ ‪ (b).6.16‬ﺑﻪ ‪ 88:1‬ﻣﻲرﺳﺪ‪ ،‬ﺑﺎﻓﺖ ﻟﺒﺎس زن و ﺗﺎري ﭼﺸﻤﻬﺎﻳﺶ ﻛﺎﻫﺶ ﻣﻲﻳﺎﺑﺪ‪.‬‬

‫ﻫﺮ ‪ 2‬ﺗﺎﺛﻴﺮ در ﺗﺼﻮﻳﺮﻫﺎي ‪ (b).6.16‬و)‪ (f‬دﻳﺪه ﻣﻲﺷﻮد‪ .‬ﺧﻄﺎي ‪ rms‬اﻳﻦ ﺑﺎزﺳﺎزﻳﻬﺎ در ﺳﻄﻮح ﺧﺎﻛﺴﺘﺮي ‪ 5.9‬اﺳﺖ‪ .‬ﻧﺘﺎﻳﺞ ﺗﺼﻮﻳﺮ ‪ 6.16‬ﺑﺎ‬

‫ﻓﺮﻣﺎﻧﻬﺎي زﻳﺮ ﺑﺎزﺳﺎزي ﺷﺪﻧﺪ‪.‬‬

‫;)'‪>> f = imread('Tracy.tif‬‬
‫;)]‪>> c1 = im2jpegek(f, 5, [8 8.5‬‬
‫;)‪>> f1 = jpeg2k2im(c1‬‬
‫)‪>> rms1 = compare(f, f1‬‬
‫= ‪rms1‬‬
‫‪3.6931‬‬
‫‪>> cr1 = imratio(f, c1‬‬

‫= ‪cr1‬‬
‫‪42.1589‬‬
‫;)]‪>> c2 = jm2jpeg2k(f, f, [8 7‬‬
‫;)‪>> f2 = jpeg2k2im(c2‬‬
‫)‪>> rms2 = compare(f, f2‬‬
‫= ‪rms2‬‬
‫‪5.9172‬‬
‫)‪>> cr2 = imratio(f, c2‬‬
‫= ‪cr2‬‬
‫‪87.7323‬‬

‫‪51‬‬
‫ﺗﺼﻮﻳﺮ ‪ .6.16‬ﺳﺘﻮن ﭼﭗ‪ :‬ﺷﺒﻴﻪ ﺳﺎزي ﺗﺼﻮﻳﺮ ‪ 6.4‬ﺑﺎ اﺳﺘﻔﺎده از ‪ 5‬ﻣﻘﻴﺎس و ﻛﻤﻲ ﺳﺎزي ﻧﻬﻔﺘﻪ ﺑﺎ‬

‫ﺳﺘﻮن راﺳﺖ‪ :‬ﻛﺴﺐ ﻧﺘﺎﻳﺞ ﻣﺸﺎﺑﻪ ﺑﺎ ‪e0=7‬‬

‫‪52‬‬
‫وﻗﺘﻲ ﻳﻚ ﺑﺮدار دو ﻋﻨﺼﺮي)‪ (two_element‬ﺑﻪ ﺻﻮرت ﺷﻨﺎﺳﻪ ‪(agrument3) 3‬از ‪ im2jpeg2k‬اراﺋﻪ ﻣﻲﺷﻮد ﻛﻤﻲ ﺳﺎزي ﻧﻬﻔﺘﻪ اﻧﺠﺎم‬

‫ﻣﻲﺷﻮد‪ .‬اﮔﺮ ﻃﻮل اﻳﻦ ﺑﺮدار ‪ 2‬ﻧﺒﺎﺷﺪ‪ ،‬ﻛﻤﻲ ﺳﺎزي ﻧﻬﻔﺘﻪ در ﺗﺎﺑﻊ ﻓﺮض ﻣﻲﺷﻮد و اﻧﺪازه ﻣﺮاﺣﻞ ‪ 3 NL +1‬ﺑﺎﻳﺪ ﻣﺸﺨﺺ ﺷﻮد )در اﻳﻨﺠﺎ ‪NL‬‬

‫ﺗﻌﺪاد ﻣﻘﻴﺎﺳﻬﺎي ﻣﺤﺎﺳﺒﻪ ﺷﺪه اﺳﺖ(‪ .‬اﻳﻦ ﻣﻘﺪار ﺑﺮاي ﻫﺮ ﻳﻚ از ﺑﺎﻧﺪﻫﺎي ﻓﺮﻋﻲ ﺗﺠﺰﻳﻪ ‪ 1‬اﺳﺖ‪ .‬آﻧﻬﺎ ﺑﺎﻳﺪ ﺑﺮ اﺳﺎس ﺳﻄﺢ ﺗﺠﺰﻳﻪ و ﻧﻮع ﺑﺎﻧﺪ‬

‫ﻓﺮﻋﻲ )ﺑﻪ ﺻﻮرت اﻓﻘﻲ‪ ،‬ﻋﻤﻮدي ﻳﺎ اري)‪(b‬ﻣﺮﺗﺐ ﺷﻮﻧﺪ‪ .‬ﻣﺜﻼً راﺑﻄﻪ زﻳﺮ‬
‫;)]‪>> c3 = im2jpeg2k(f, 1, [1 1 1 1‬‬

‫ﻳﻚ ﺗﺒﺪﻳﻞ ﺗﻚ ﻣﻘﻴﺎﺳﻲ را ﻣﺤﺎﺳﺒﻪ ﻛﺮده و از ﻛﻤﻲ ﺳﺎزي ﻋﻠﻨﻲ ﺑﻬﺮه ﻣﻲﮔﻴﺮد‪ .‬ﻛﻠﻴﻪ ﭼﻬﺎر ﺑﺎﻧﺪ ﻓﺮﻋﻲ ﺑﺎ اﺳﺘﻔﺎده از ﻣﺮﺣﻠﻪ ‪ ∆1=1‬ﻛﻤﻲ ﺳﺎزي‬

‫ﻣﻲﺷﻮﻧﺪ‪ .‬ﻳﻌﻨﻲ ﺿﺮاﻳﺐ ﺗﺒﺪﻳﻞ ﺑﻪ ﻧﺰدﻳﻜﺘﺮﻳﻦ ﻋﺪد ﺻﺤﻴﺢ ﮔﺮد ﻣﻲﺷﻮﻧﺪ‪ .‬اﻳﻦ ﺣﺪاﻗﻞ ﺧﻄﺎ را ﺑﺮاي اﺟﺮاي ‪ im2jpeg2k‬اﻳﺠﺎد ﻣﻲﻛﻨﺪ و ﺧﻄﺎي‬

‫‪ rms‬و ﻧﺴﺒﺖ ﻓﺸﺮدهﺳﺎزي ﺣﺎﺻﻞ از آن ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ‪:‬‬

‫;)‪>> f3 = jpeg2k2im(c3‬‬
‫)‪>> rms3 = compare(f, f3‬‬
‫= ‪rms3‬‬
‫‪1.1234‬‬
‫)‪>> cr3 = imratio(f, c3‬‬
‫= ‪cr3‬‬
‫‪1.635‬‬

‫ﺧﻼﺻﻪ ﻣﻄﺎﻟﺐ ) ‪(Summary‬‬

‫ﻣﻄﺎﻟﺐ اﻳﻦ ﺑﺨﺶ اﺻﻮل ﻓﺸﺮدهﺳﺎزي ﺗﺼﻮﻳﺮﻫﺎي دﻳﺠﻴﺘﺎﻟﻲ از ﻃﺮﻳﻖ رﻣﺰﮔﺸﺎﻳﻲ و ﺣﺬف اﻓﺰوﻧﮕﻲ رواﻧﻲ – ﺗﺼﻮﻳﺮي و ﺑﻴﻦ ﭘﻴﻜﺴﻠﻲ اﺳﺖ‪.‬‬

‫روالﻫﺎﻳﻲ ﺑﺮاي ﺣﺬف اﻓﺰوﻧﮕﻲ در ﻧﺮم اﻓﺰار ‪ MATLAB‬و ﺗﻮﺳﻌﻪ اﺑﺰار ﭘﺮدازش ﺗﺼﻮﻳﺮ اﺑﺪاع ﺷﺪه اﺳﺖ‪ .‬ﻣﻌﻴﺎرﻫﺎي اﺳﺘﺎﻧﺪارد ﻓﺸﺮدهﺳﺎزي‬

‫ﺗﺼﻮﻳﺮﻫﺎي ‪ Jpeg‬و ‪ Jpeg2000‬ﻧﻴﺰ اراﺋﻪ ﺷﺪه اﺳﺖ‪ .‬ﺑﺮاي ﻛﺴﺐ اﻃﻼﻋﺎت ﺑﻴﺸﺘﺮ در ﺧﺼﻮص ﺣﺬف اﻓﺰوﻧﮕﻲ ﺗﺼﻮﻳﺮﻫﺎ و ﺷﮕﺮدﻫﺎي ﺗﺸﺮﻳﺢ‬

‫ﻧﺸﺪه در اﻳﻨﺠﺎ و اﺳﺘﺎﻧﺪاردﻫﺎي ﻣﺮﺑﻮط ﺑﻪ ﻣﺠﻤﻮﻋﻪ ﺗﺼﻮﻳﺮﻫﺎي ﻣﺨﺼﻮص )ﻣﺎﻧﻨﺪ ﺗﺼﻮﻳﺮﻫﺎي دودوﻳﻲ( ﻛﻨﻴﺪ‪.‬‬

‫‪53‬‬