An Image Compression Technique based on Range

Assignment Problem using Dynamic Programming

and Segment Tree

Farras Mohammad Hibban Faddila / 13518017

Program Studi Teknik Informatika
Sekolah Teknik Elektro dan Informatika
Institut Teknologi Bandung, Jalan Ganesha 10 Bandung
faddilafarras@gmail.com

Abstract—Image Compression is widely used for obvious
purpose: to minimize the amount of memory taken inside the
storage without losing any substantial visual information
contained inside the image. There are various techniques of
image compression available, such as Huffman Encoding and
Run Length Encoding (RLE). Here we discuss a novel technique
to reduce spatial redundancy which is familiar to RLE by storing
the image into several intervals of pixel values. This technique
could also be combined with Huffman Encoding, removing
coding redundancies, to achieve better performance.
Keywords—image, compression, run length encoding, dynamic
programming, segment tree
I. INTRODUCTION
Image is a representation of visual information or picture in
a two-dimensional space [1]. This piece of information could
hold spatial information which is not available at other data,
such as texts. To represent spatial information in a two-
dimensional space, an image is basically created from a two-
dimensional array (or matrix), in which each element of the
matrix at a position (x,y) holds a value corresponding to the
brightness of the picture at the position mapped to the
coordinate (x,y). Each of these positions is called a pixel. Since
an image is two-dimensional, to embed our environment into
an image, there is some spatial mapping required to put the
view we see into the image. In other word, each pixel
corresponds to a position in the real word.
The study about image is very broad. At one end, there is a
study on how to capture image from the real word and convert
them into stream of bytes to be processed later by software or
manually by human hand. This is the part which requires some
low-level programming and understanding of physics (such as
light sensor, etc.). Then, after the digital device obtains the
picture in terms of bytes of memory, there is a need to visualize
the captured information into the screen for other people to be
able to view them. This is the field of Computer Graphics. It’s
used in digital photography, film and television, video games,
and on electronic devices. This field aims to display images
(graphics) effectively to users in the screen, using some
primitives such as lines, circles, etc. User could then view
images on the computer screen, which depicts the real-world
environment.
On the other end, there is Pattern Recognition or Image
Recognition. Sometimes we need to obtain information from
one or several images. The information might be easy to be
obtained manually using human capability, but nowadays there
are several use-cases which requires the machine to have these
capabilities automatically. Several examples of these use-cases
are face recognition for attendance management system,
transportation plate recognition in CCTV, and so on. A
machine having this recognition capability is really useful,
because a machine could process large amount of data in less
amount of time, so there are many tasks that could be
automated. The field of pattern recognition in image aims to
get machines to perform these recognition tasks, and the output
might be some descriptions of the image, such as what objects
are inside the image, how many people are there in the image,
who are inside the image, how do the text inside the image
reads, and many other tasks. Basically, nowadays these tasks
are done by the machine using learning algorithm.
In the middle of these process, there is Image Processing.
This image aims to improve the quality of the image for easier
next usage, by humans or by machines [1]. Basically, operators
in Image Processing maps an image into other image by some
functions, in which the output image is expected to not have
issues or problems the initial image has in the first place. For
example, some problems in Image Processing are Image
Enhancement (enhancing image brightness in case the captured
image is too dark), Image Deblurring (removing blur in the
initial image), Image Restoration (restoring image from
problems such as blurs and noises caused by for example aging
picture).
Another problem which occurs in Image Processing is
Image Compressing. We need several information to represent
an image (such as the brightness value of each pixel, as have
been discussed previously). To have a better quality, an image
normally should have a higher number of pixels, so that the
image would be more continuous mathematically and smoother
visually. This means, the image needs to store more values, and
more memory is required to store the image inside the storage

Makalah IF4073 Interpretasi dan Pengolahan Citra, Semester I Tahun 2023/2024

device. Therefore, image compression techniques are created to
reduce the number of the data without removing number of
information contained inside the image. The process consists of
two steps: compression and decompression of the image.
There are two kinds of compression techniques: lossless
and lossy. The lossy compressions remove some parts of the
data inside the image without altering much of the visual
appearance of the image. The decompression result of the lossy
algorithms is not one hundred percent equal with the initial
image before compression, but visually the result will still be Fig. 1. Pixel-based image representation as a two-dimensional array
the same with the initial image. The lossless technique, on the
other hand, does not remove any information. The technique The number of total pixels in an image is simply the
does this by removing some redundancies inside the image, product of the width and the heights (M x N). The more pixels
such as coding redundancy, spatial redundancy, and/or psycho- there are, the sharper the image becomes, because more pixels
visual redundancy. mean the image is sampled from more points, so it is going to
be more similar to the original signal from the real world, the
continuous one.
II. THEORETICAL BACKGROUND
The value in the digital image could also be called the color
A. Digital Image Representation of the image in that position. There are several color systems
In the digital devices, there are several ways on how an with different rules, so for an image there might be more than
image could be stored. First, there is a pixel-based one representation based on the color systems being used. The
representation, and also there is a vector-based representation. most basic color system is RGB (Red, Green, Blue). In RGB
A pixel-based representation partitions the image into a grid of color system, there are three channels, one for each color red,
a certain dimension (width × height), and each pixel has one green, and blue. Each channel is an M x N matrix, so in an
value which correspond to the light intensity at that position. RGB image, the size of the matrix is M x N x 3, i.e. each
On the other hand, vector-based representation takes into position has three values for each channel. These three values
account that an image is composed of primitives such as lines, are then used to obtain the true colors of the pixel, shown in the
circles, or curves, so that the components of the images is figure below. Each value can be from 0 to 255 (with data type
specified by those information. One advantage of this integer) or norm
representation is that when zooming an image, the image could
be reconstructed using the equations, so that there is no loss of
sharpness. In the pixel-based representation, however, when
zooming out the picture the pixel size relative to the image
stays the same, and to increase sharpness we need to
interpolate the image, which could not be done automatically
and/or easily like what the vector-based representation does
with the equations of the lines and circles.
We are going to discuss more about the pixel-based
representation, since the compression technique in this paper is
used in pixel-based images. In the pixel-based representation,
digital image is represented as a two-dimensional array (or
matrix). Each element of the array has a value corresponding to
the brightness or light intensity in that position. More formally,
in the position (x, y), we have a value f(x, y), where f is a
function. Naturally, in the real world, f is continuous, but in Fig. 2. RGB color space graph
practical, the computer could not store all of the values in this
continuous function. The values of the function f result from a Each value can be from 0 to 255 (with data type integer) or
sampling (samples a position into a discrete position) and the normalized to between 0 to 1 (real-valued). When the
continuous values in the sampled area is quantized into integer components of red, green, and blue are all the same, the
values corresponding to the color space. For a digital image resulting color will be grayscale.
with width N and height M, the shape of the image is as
follows. There are several other color spaces. First, HSI (Hue,
Saturation, Index), for which the value is more describable by
human visually. Hue is the true color attribute, saturation is the
level of the lights in the color, i.e. how many whiteness is given
to the color, and intensity is the amounts of lights received by
the eye independent of the color.

Makalah IF4073 Interpretasi dan Pengolahan Citra, Semester I Tahun 2023/2024

B. Image Compression
As have been discussed earlier in the introduction, Image
Compression is a technique to compress image into smaller
size to reduce the amount of storage taken in the storage disk.
Compressing image also have other benefits, such as faster
image transmission in a network, since the number of the bytes
transferred is less. Images are then decompressed when it is
displayed on a computer screen, or it needs to be printed, or has
to be stored in a non-compressed format [4]. Images need to be
compressed because digital images need large memory. The
aim of image compression is to reduce the needs of storage
space while still keeping the quality of the image visually [5],
and also to represent image in the similar quality with the
original image but in a more compact state.
There are two kinds of compression techniques: lossless
and lossy. The lossy compressions remove some parts of the
data inside the image without altering much of the visual
appearance of the image. The decompression result of the lossy
algorithms is not one hundred percent equal with the initial
image before compression, but visually the result will still be
the same with the initial image. Examples of the real-world
lossy compression techniques are JPEG, MPEG, HEIC. The
lossless technique, on the other hand, retains information
contained in the image. The technique does this by only
removing redundancies inside the image, such as coding
redundancy, spatial redundancy, and/or psycho-visual
redundancy.
Coding redundancy is related to the number of bits needed
to represent each symbol in the data. Ideally, the symbol that
occurs more should be represented with bits of shorter lengths.
In a uniform bit representation, each data is represented with
bits of the same length, so the average length of each bit is the
same as the length of each individual symbol. However, in
information theory, the average number of bits required to
represent each element of a message could be calculated, and
this value would be smaller for a more non-uniform probability
density function (pdf) of the appearance of the elements.
Fig. 3. Information Entropy by C. Shannon (1948)
Spatial redundancy is related to the fact that in an image,
neighboring pixels might have similar intensity values, or not
differing by much, except in the borders. Especially in the
image segmentation problems, each segment consists of parts
in the images which has similar pixel value. This redundancy
can be handled for example by dividing the rows into some
intervals which have same values, so there is no need to store
each value at the middle of the interval; only the left border and
the right border (or the length of the interval) and the value of
the pixel is stored. Lastly, psycho-visual redundancy is a
redundancy in which some information is visually not
Makalah IF4073 Interpretasi dan Pengolahan Citra, Semester I Tahun 2023/2024
important, so it is accepted to just remove that information. For
example, by quantifying an image to a lower bit level, since the
difference in the lower bit level cannot be comprehend
visually.
C. Huffman Coding Compression
Huffman Coding is a lossless image compression technique
to handle the coding redundancy issue explained earlier. The
algorithm is used to obtain an encoding of each symbol (in this
case pixel values) in the message (in this case, image), so that
the more occurring values are mapped to shorter sequences of
bits, to achieve a lower entropy and a lower total number of
bits needed to represent the image. The Huffman Coding
compression works using a greedy approach and, the output of
the algorithm is a tree which is used to obtain the new codes
for each symbol. The algorithm is as follows [4].
1. Create several nodes which stores the symbol and
their frequency in the message. These nodes are put in
a priority heap to easily find the nodes with smallest
frequencies. These nodes is going to be the leaves of
the final resulting tree.
2. Pick two nodes in the heap with smallest frequencies,
remove them from the heap, join them together to
form a new node which is going to be their parent in
the tree. This new node has the sum of its children’s
frequencies as its frequency. Insert this new node into
the heap
3. Repeat process 2 until only one node remains inside
the heap, which would actually store the total
frequency of all symbols. This final node is the root of
the tree.
4. For each non-leaf node, label the edges to the children
0 and 1 for the left child and the right child
respectively.
5. To obtain a new code for a symbol, traverse down the
tree from the root to the leaf which corresponds to that
symbol. While traversing down the tree, write down
the bits encountered on the visited edges. These
concatenated bits are going to be the Huffman code
for that symbol.
Fig. 4. Example 1 of Huffman Encoding
This is an example of the leaf nodes of a Huffman Tree, for
which a (7;0.02) means the symbol 7 has a frequency of 0.02 of
the total frequency.
Fig. 5. Example 2 of Huffman Encoding

In the first step, the nodes with symbol 6 and 7 are the
nodes with smallest frequencies (0.02 and 0.03 respectively),
so they are joined to create a new parent node with frequency
0.05.
Fig. 6. Example 3 of Huffman Encoding
Then in the next step, the node with symbol 5 and the node
from the previous step have the smallest frequencies (0.06 and
0.05 respectively), so they are joined to create a new parent
node with frequency 0.11. This process is continued until only
a connected component remain.
D. Run Length Encoding
Run Length Encoding (RLE) is used to remove spatial
redundancy. Basically, for each row of the image, it
compresses intervals with the same pixel values, only storing
the values and the length of the interval. In the extreme cases,
this could compress a row with all same values of pixels into
only two values, the width of the image, and the pixel of value.
For example, in a row with values [3, 3, 3, 4, 4, 4, 4, 4, 3, 3, 3,
4], RLE compresses the array into the following: [(3, 3), (4, 5),
(3, 4)] because there are three 3’s, followed by five 4’s, and
then four 3’s. This is a lossless compression technique since we
don’t remove any information, and we can reconstruct the
initial array from the compressed array without any loss of
information, by simple iteration.
E. Dynamic Programming
Dynamic Programming (DP) is a problem-solving
paradigm by decomposing the solution into several stages, so
that the entire solution (final stage) could be derived from the
previous stage, which are connected to each other [3]. DP
could be used to solve optimization problems, such as
minimization or maximization. In DP paradigm, we consider
every next decision state possible, obtain their optimal values
by some transition to the previous state, and store these optimal
values in a table for future purposes by the next state. In
contrast, in the greedy approach we only consider one next
state, which optimizes the current state (but might not
necessarily leads us to the global optima).
There are two different types of DP: the top-down approach
and the bottom-up approach. In the top-down approach, we
start from the final state (the entire solution we care about), and
optimize this state result from the previous states, in which the
values are obtained recursively. On the other hand, in the
bottom-up approach, we fill the DP table from the base case
(initial states) up to the final state iteratively. Several classical
algorithmic problems which could be solved using dynamic
programming are shortest path problem, knapsack, longest
Makalah IF4073 Interpretasi dan Pengolahan Citra, Semester I Tahun 2023/2024
increasing subsequence (LIS), coin change problem, and
finding edit distance between two words.
Sometimes in a dynamic programming problem, we don’t
only need the optimum value, but we also need to find out the
steps that lead to that optimum value. To do this, we need to do
backtracking. When we update a state value with a better value
from transition with the previous state, we assign this previous
state as the parent state of the current state. This way, we could
start from the final state, traversing to the parent state of the
current state in each step, to find out the path from the initial
state that leads to the optimum final state.
F. Segment Tree
Segment tree is a tree-based data structure that stores
information about array intervals as a tree [2]. It is used to
obtain aggregate information over an interval of an array (such
as sum, product, greatest common divisor, or other associative
operations) in O(log n) time complexity without the need to
loop over the intervals and doing the operations one by one
(which requires O(n) time complexity on average. Segment
tree also supports an update operation (update value of
elements of array), whether single update or range update
(multiples consecutive elements at once) in O(log n).
Segment tree basically stores several intervals information
of the array. Let the length of the array be n. The root of the
segment tree stores the information of the interval with length
n, i.e. the entire array. Then, each child of the root stores the
information of the left half and the right half of the array,
respectively, in which each of them has length of n/2. This
process is continued recursively, and each leaf of the segment
tree stores information of individual element of the array. Since
in each level the size of the interval is halved, therefore the
number of the levels in a segment tree is k, where 2 k ~ n, for
which k is approximately O(log n). And since in the i-th level
there is 2i node, therefore the number of nodes is
approximately 20 + 21 + … + 2k = 2k+1 – 1 ~ 2n, which is still
linear in n.
Fig. 7. Illustration of Segment Tree (cp-algorithms.com)
 In the example of segment tree in figure 7 above, we store
the array a = [1, 3, -2, 8, -7] in the segment tree, and store the
sum of elements of each interval inside each node. The root
node stores the sum of the elements in the interval 0 to 4,
which is 3. The left child of the root stores the sum of the
elements in the interval 0 to 2, which is 2, and the right child
stores the sum of the elements in the interval 3 to 4, which is 1.
The process of building the segment tree is continued
recursively to the bottom of the tree. By storing the information
of sum of elements in each node, we can obtain the sum of the
consecutive elements of the tree effectively in O(log n) by
traversing down the tree.
G. Range Assignment Problem
Range assignment is a problem is an algorithmic problem,
notably appears in programming problems, in which there are
several range assignment queries. Basically, the problem
formulation is as follows.
Given a zero-indexed array A of size N, in which the
elements are A[0], A[1], A[2], …, A[N – 1]. We are given Q
queries, in which each of them consists of three numbers L, R,
and V. For each query, in order they are given, we need to
assign elements of the array A from the index L to index R
with value V. A usual iterative approach (assigning A[L] to
A[R] to V iteratively using for loop) cost us R-L+1 operations,
which in the worst case is N operations, and on average N/2
operations, which is still O(N). Therefore, the total complexity
of this algorithm is O(QN).
We can optimize the time complexity, albeit in the cost of
more memory using a segment tree and lazy propagation
technique. A segment tree only requires two times the size of
the array, so it is still linear. The time complexity is O(log N)
for each query using the segment tree, so the total will be O(Q
log(N)).
III. IMPLEMENTATION
Now, we try to implement the compression algorithm.
Consider an image of size W x H. Now, we focus on a single
row, which is an array A of size H. Each element in this array
is the pixel brightness value, which ranges from 0 to 255. Now,
we consider the following problem: how many assignment
queries, defined in the range assignment problem above, in
minimum we need to perform to obtain the exact array A?
Let’s say we are able to solve this problem and obtain Q
queries (L1, R1, V1), (L2, R2, V2), (L3, R3, V3), …, (LQ, RQ, VQ).
The details of the algorithm is specified later at the end of this
section. By our definition of Q, Q must not be greater than the
number of the intervals the RLE produces. After that, for the
compressed data, we save these range assignment values for
each row. To perform the decompression, we perform the
range assignment of each row one by one using the queries we
save in the compression data. This way, in the end for each row
we will have the initial row array so that the image is restored.
The details of the algorithm are as follows.
1. For the compression, consider a row. Use dynamic
programming with backtracking to create the minimal
number of queries assignment needed to obtain that
row.
Makalah IF4073 Interpretasi dan Pengolahan Citra, Semester I Tahun 2023/2024
2. Do step 1 for each row to get the compression of the
entire image.
3. Find out the frequency of each symbol (left bound,
right bound, and the pixel values) and perform
Huffman encoding to encode those symbols to further
remove redundancies from the image.
4. Use Huffman table to map each code into the original
symbol.
5. For the decompression of the image, consider
compression (range assignment queries) of a row. Use
segment trees with lazy propagation to perform the
range assignment effectively.
6. Do step 5 for each row.
The following illustrates the details on the algorithms
above. Let’s say we have an array A = [1, 1, 1, 2, 2, 2, 2, 2, 3,
3, 2, 2, 2, 2, 1, 1, 4, 5, 5, 5, 4, 4, 1, 1, 1]. RLE would encode
this into [(1, 3), (2, 5), (3, 2), (2, 4), (1, 2), (4, 1), (5, 3), (4, 2),
(1, 3)], which consists of 18 values. Using the technique
described here, the dynamic programming with backtracking
will compress array A into the following queries Q: [(1, 25, 1),
(4, 14, 2), (9, 10, 3), (17, 22, 4), (18, 20, 5)], which only consist
of 15 values. What does these number mean? This means,
starting from unassigned array B with size same as A (which is
25), and performing the queries in Q one by one, we will get A.
For example:
1. Start from B = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
2. The first query is (1, 25, 1), which means we assign
A[i] := 1 for each i = 1 to 25: [1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
3. The next query is (4, 14, 2), so we assign A[i] := 2 for
each i = 4 to 14: [1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
4. From query (9, 10, 3), we assign A[i] := 3 for each i =
9 to 10: [1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1]
5. From query (17, 22, 4), we assign A[i] := 4 for each i
= 17 to 22: [1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 2, 2, 2, 2, 1, 1,
4, 4, 4, 4, 4, 4, 1, 1, 1]
6. From query (18, 20, 5), we assign A[i] := 5 for each i
= 18 to 20: [1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 2, 2, 2, 2, 1, 1, 4,
4, 5, 5, 4, 4, 1, 1, 1]
7. Now, the resulting array is same as A.
Another easier example is the following: In the array [1, 2, 1], a
standard RLE encodes it into [(1, 1), (2, 1), (1, 1)] and our
approach encodes it into [(1, 3, 1), (2, 2, 2)]
Finally, we describe the approach to generate the queries.
We perform the following bottom-up dynamic programming
with O(W3) time complexity and O(W2) space complexity. Let
A be the array we want to generate the assignment queries
with.
ASSIGNMENT-QUERY(A)
0. n = size(A) parts with their value, which is done by the RLE. So, this
compression technique would perform at least as good as RLE
1. let dp[1..n][1..n] be a new array in terms of the memory size, at the cost of the time needed for
2. for i = 1 to n the compression and the decompression process. For an RLE,
the decompression takes O(W) operation in a row regardless of
3. for j = 1 to n the number of the intervals of the same values, so the total time
4. dp[i][j] = n complexity is O(HW). However, in this Image Compression
algorithm, the decompression stage takes O(Q log(W))
5. let ps[1..n][1..n] be a new array operation to perform the range assignment and O(W log(W))
6. for length = 1 to n operations to determine the value of each pixel element, so the
total time complexity is O((Q + W) log(W)), and for the entire
7. for left = 1 to n – length + 1 image, it would be O(H (Q + W) log(W)). Note that the value
8. right = left + length – 1 of Q is bounded by W above, so the complexity would not be
worse than O(HW log(W)). Taking the Huffman complexity
9. j = -1 into account, which is O(L log(L)), where L is the number of
different symbols (number of different color level, number of
10. for i = left to right - 1
different possible interval lengths and indices), the following
11. if A[i] ≠ A[right] and j == -1 then table summarizes the complexity of the proposed algorithm.
12. j=i
TABLE I. TIME COMPLEXITY OF COMPRESSION
13. if j ≠ -1 then
Stage RLE Proposed Method
14. if dp[left][right] > 1 + dp[j][i] + dp[i + 1][right]
Compression O(HW) O(HW3)
15. dp[left][right] = 1 + dp[j][i] + dp[i + 1][right]
Decompression O(HW) O(HW log(W))
16. ps[left][right] = [j, i, right]
17. if j == -1 then In terms of memory complexity of the compression, we
gained an advantage. This is demonstrated in the example
18. dp[left][right] = 0 above in the previous part of the paper. However, we don’t
19. BACKTRACK(ps, 1, n, result_queries, A) currently know how memory-efficient is this compression
algorithm compared to standard RLE, since we need to find out
20. return result_queries, dp[1][n] + 1 the behavior when does our DP algorithm produces far less
interval query than the obvious one the RLE created, and how
often does that arises.
To perform the backtracking, we use the auxiliary array ps
obtained during the DP stage, and solve it recursively for each V. CONCLUSION AND SUGGESTION
interval.
The spatial redundancy arises in images, or more
BACKTRACK (ps, left, right, result_queries, A) specifically visually meaningful images, so an algorithm like
RLE which compresses interval would be beneficial since on
0. if ps[left][right] is nil then
average, the number of intervals with same value of pixel will
1. result_queries push (left, right, A[right]) be high from the spatial redundancy. This regularity in the
spatial information makes a case like each pixel in each row
2. return has different value highly improbable.
3. result_queries push (left, right, A[right]) This paper discusses an original technique for performing
4. j = ps[left][right][0] the row compression, based on dynamic programming and
backtracking, and also for performing the row decompression,
5. i = ps[left][right][1] using segment tree data structure. The time complexity is
6. BACKTRACK (ps, j, i, result_queries, A) slower than the standard RLE, but in some cases this method
gives a more efficient compression than the standard RLE. One
7. BACKTRACK (ps, i + 1, right, result_queries, A) example is in a picture with a background, and the background
is crossed several times. For example, a sky with several
skyscrapers. Using standard RLE, there would be several
numbers of intervals for the sky color. but using our approach,
IV. RESULT AND ANALYSIS we only need to save an interval for the sky color.
A. Complexity Analysis
Theoretically, to compare this technique with RLE, we see
that one of the obvious range assignments would be to divide
the array into parts of same values, and assign each of these

Makalah IF4073 Interpretasi dan Pengolahan Citra, Semester I Tahun 2023/2024

Fig. 8. An image with sky background and skyscrapers [2]
One thing that could be suggested is to further perform an [3]
analysis on how to measure the memory efficiency of this
approach compared to the standard RLE. To do this, we need
to measure the expected value of Q/R, where Q is the number [4]
of queries obtained using the DP, and R is the number of the
[5]
obvious interval using RLE, which might be computationally
expensive, but might be able to be approximated.
https://cp-algorithms.com/data_structures/segment_tree.html, accessed
on 18 December 2023
https://informatika.stei.itb.ac.id/~rinaldi.munir/Stmik/2020-
2021/Program-Dinamis-2020-Bagian1.pdf, accessed on 18 December
2023
https://informatika.stei.itb.ac.id/~rinaldi.munir/Citra/2023-2024/25-
Image-Compression-Bagian1-2023.pdf, accessed on 18 December 2023
R. C. Gonzalez and R. E. Woods, “Digital Image Processing”, 3 rd Ed,
Prentice Hall

REPOSITORY LINK AT GITHUB STATEMENT

https://github.com/donbasta/compression-assignment I hereby declare that this paper is written originally by myself,
not a copy, a translation, or plagiarized from any other
sources.
ACKNOWLEDGMENT Bandung, 19 December 2023
First, I thank God, Allah SWT, for His Blessings and His
Grace so that I could have the opportunity to write this paper. I
am also deeply thankful to Dr. Ir. Rinaldi Munir, M.T., who
has taught us for the last semester about Image Processing,
provided us with invaluable materials regarding the topic and
also has encouraged us to do this paper. Lastly, I want to
extend my appreciation to my friends which have supported me Farras Mohammad Hibban Faddila / 13518017
emotionally during the writing of this paper.

REFERENCES
[1] https://informatika.stei.itb.ac.id/~rinaldi.munir/Citra/2022-2023/01-
Pengantar-Pengolahan-Citra-Bag1-2022.pdf, accessed on 18 December
2023

Makalah IF4073 Interpretasi dan Pengolahan Citra, Semester I Tahun 2023/2024