Structure-Aware Pixel Art Scaling via Block Size Detection

Abstract

Standard interpolation methods degrade pixel art through blurring or geometric distortion. We propose a lossless scaling algorithm that detects the intrinsic block size to normalize the image grid, thereby expanding the set of valid scaling factors beyond standard integer multiples. This approach enables precise, distortion-free resizing closer to user-specified scales. To validate this approach, we introduce a novel evaluation framework consisting of Color Loss (CL), Block Size Consistency (BSC), and reversibility (REV) tests. Experimental results demonstrate that the proposed method maintains the original palette and grid structure without introducing interpolation artifacts. Furthermore, the reversibility tests confirm that the scaling process remains mathematically lossless, ensuring the genre’s structural and chromatic integrity.

1. Introduction

Pixel art originated as a necessity due to the low-resolution constraints of early computer hardware [1], but it has since evolved into a distinct digital art form appreciated for its unique aesthetic value [2,3]. Unlike continuous-tone images, pixel art is visually characterized by a grid-based arrangement [4] of uniform color regions and intentionally emphasized stair-step effects (aliasing) [5]. With the resurgence of retro-style games [6,7] and the proliferation of high-resolution displays, there is a growing demand for resizing low-resolution pixel art to fit various modern screen aspect ratios and resolutions [5,8,9].

This necessity for high-quality resizing aligns with broader objectives in computer vision, where maintaining structural consistency and ensuring reversibility under geometric transformations have emerged as critical challenges. For instance, Liu et al. [10] demonstrated that learning robust feature representations is essential for maintaining structural consistency across scale variations in complex scenes. Similarly, Wang et al. [11] emphasized the importance of reversible and structure-preserving designs to ensure data integrity against geometric attacks. These cross-domain insights underscore the core requirements of pixel art resizing: preserving the discrete block structure and ensuring reversibility are paramount to maintaining the artwork’s identity.

However, standard image interpolation methods are ill-suited for meeting these rigorous requirements. Conventional resampling algorithms, such as bilinear or bicubic interpolation, calculate new pixel values by averaging neighbors [12,13,14,15]. While effective for photographs, this process introduces blurring artifacts that destroy the sharp boundaries and discrete block structure essential to pixel art. Conversely, Nearest Neighbor interpolation, which is often recommended for preserving hard edges, exhibits critical limitations when the scaling factor is not an integer [16]. In such cases, Nearest Neighbor causes geometric distortion—commonly referred to as “shimmering” or “pixel wobble”—where the uniform block sizes become irregular, severely compromising the structural integrity of the artwork.

Existing solutions, such as pixel-art-specific algorithms like Scale2x or xBRZ, mitigate these issues but are typically limited to fixed integer scaling factors (e.g., $2\times$, $3\times$). To overcome such rigid constraints, recent deep learning-based approaches have focused on flexible and high-fidelity upscaling. Notably, models like Real-ESRGAN and the Implicit Transformer Network (ITSRN) have demonstrated significant success in super-resolution for non-photorealistic images. However, these methods tend to either aggressively smooth out details to produce vector-like aesthetics (depixelization) or infer continuous color values that violate the discrete palette, failing to preserve the strict pixel-grid alignment and aliased aesthetics fundamental to the pixel art domain. Consequently, there is a need for a more robust scaling methodology that can approximate arbitrary user-specified scales without introducing visual artifacts.

In this paper, we propose a novel lossless scaling methodology that addresses these limitations by leveraging the intrinsic structural property of pixel art: the “Block Size”. We formally define the Block and Block Size (n) as the fundamental structural units of the image. Our algorithm detects the inherent block size n of an input image and normalizes it to a unit grid ($n=1$). This normalization process allows us to expand the set of valid scaling factors beyond simple integer multiples, enabling precise, distortion-free resizing that closely approximates the user’s desired dimensions.

The main contributions of this paper are summarized as follows:

1.

We introduce an algorithm to detect the intrinsic block size of a pixel art image and restore it to its original unit grid representation.

2.

We demonstrate that our method significantly expands the range of valid, lossless scaling factors compared to traditional integer scaling, allowing for flexible resizing proportional to the detected block size.

3.

To quantitatively validate our approach, we propose a novel evaluation framework consisting of Color Loss (CL), Block Size Consistency (BSC), and reversibility tests (REVs). Comparative experiments show that our method is the superior solution that preserves both the chromatic and structural integrity of pixel art across an expanded range of scales.

The remainder of this paper is organized as follows. Section 2 reviews traditional image interpolation methods and algorithms specifically tailored for pixel art. Section 3 analyzes the limitations of these traditional methods and defines the concept of “integrity,” which serves as the core objective of this study. Based on this definition, Section 4 proposes a new resizing methodology designed to maintain pixel art integrity. Section 5 presents the experimental results, comparing the proposed method against existing techniques to validate its effectiveness, and discusses the limitations of the study. Finally, Section 6 concludes the paper and outlines future research directions.

2. Related Works

2.1. Traditional Image Resizing Methods

Traditionally, image resizing employs interpolation methods, with the three most commonly used being Nearest Neighbor, Bilinear, and Bicubic interpolation [12,15]. This study does not develop or utilize a separate interpolation algorithm; instead, it focuses on resizing pixel art based on Nearest Neighbor interpolation and integer-based scaling.

2.2. Scale2x

Scale2x [17] is a specialized algorithm designed to enhance low-resolution graphics, originally developed for the AdvancedMAME emulator. It operates by analyzing the topological pattern of the surrounding eight pixels to generate intermediate pixels, thereby doubling the image resolution. While the algorithm can be extended to $3\times$ scaling (Scale3x) or combinations thereof, it remains fundamentally restricted to integer multipliers, lacking support for fractional scaling factors such as 1.5×.

As illustrated in Figure 1, Scale2x effectively mitigates the stair-step artifacts (aliasing) by rounding off corner pixels. However, this morphological modification transforms the original square blocks into smoother, curve-like shapes. While visually pleasing for certain intricate sprites, this alteration fundamentally deviates from the original block structure, failing to preserve the integrity, which is the focus of this study.

2.3. xBRZ

xBRZ (scale by Rules-Zenju) [18] represents a significant evolution in rule-based scaling, building upon the concepts of the xBR algorithm to address the limitations of earlier methods like Scale2x. Unlike Scale2x, which relies on simple corner-rounding rules, xBRZ utilizes a complex set of pattern recognition rules to analyze the local neighborhood of each pixel and determine edge directionality. This approach allows it to interpret low-resolution sprites as smooth, vector-like curves, effectively eliminating the “staircase” artifacts typical of aliasing.

As shown in Figure 2, the algorithm’s ability to produce high-quality, continuous lines has led to its widespread adoption in prominent emulation platforms, including DOSBox, Snes9x, and ScummVM. However, despite its popularity in the emulation community, its aggressive smoothing generates an overly stylized, “oil painting” effect that deviates from the original blocky aesthetic of pixel art. Furthermore, like Scale2x, xBRZ is primarily optimized for fixed integer scaling factors, limiting its applicability in scenarios requiring arbitrary or dynamic resizing.

2.4. Implicit Transformer Network (ITSRN)

While traditional rule-based methods like Scale2x and xBRZ are limited to fixed integer scaling, recent advancements in deep learning have introduced implicit neural representations to achieve arbitrary-scale super-resolution. A prominent example is the Implicit Transformer Network (ITSRN) [19], which was proposed to handle the Screen Content Images (SCIs) typically found in remote desktop sharing or online education scenarios. ITSRN employs an implicit transformer to query pixel values at arbitrary continuous coordinates, allowing for flexible resizing ratios that are not constrained to integers.

However, applying ITSRN directly to pixel art reveals critical limitations, particularly regarding color fidelity. As demonstrated in Figure 3, while the model maintains a structural sharpness comparable to Nearest Neighbor interpolation, it introduces significant chromatic artifacts. Since the deep learning model infers pixel values in a continuous color space, it fails to adhere to the strict, limited color palette characteristic of pixel art. Consequently, the resulting image suffers from color bleeding and noise, compromising the chromatic integrity of the original artwork, even if the block structure is relatively well-preserved.

2.5. Real-ESRGAN

Real-ESRGAN [20] is a seminal Generative Adversarial Network (GAN)-based super-resolution framework, widely adopted for synthesizing realistic textures and cleaning up compression artifacts. It is particularly effective for anime and illustration upscaling, leveraging a powerful discriminator to generate sharp, visually pleasing details.

As demonstrated in Figure 4, Real-ESRGAN exhibits characteristics similar to xBRZ in that it maintains the structural edges of the artwork while smoothing the diagonal lines intended by the artist. However, compared to xBRZ, the degradation of the color palette is notably more severe. While xBRZ generally preserves the local dominant colors, Real-ESRGAN generates numerous intermediate color values to achieve smooth transitions. This results in a “depixelized”, vector-like appearance that fundamentally alters the intended retro aesthetic and violates the chromatic integrity required for authentic pixel art resizing.

3. Problem Statement

When resizing pixel art images, Nearest Neighbor interpolation is widely regarded as the standard approach [21]. Unlike continuous-tone image interpolation methods such as Bilinear or Bicubic, which average neighboring [14,15] pixel values, Nearest Neighbor preserves the discrete pixel values. As illustrated in Figure 5, conventional methods smooth out the distinctive [5] stair-step patterns of pixel art, introducing blurring artifacts that fundamentally degrade the artwork’s intended aesthetic [16,22].

However, even Nearest Neighbor interpolation is not without limitations. When the scaling factor is not an integer, the inherent grid structure of pixel art leads to geometric distortion [16], commonly referred to as shimmering or pixel wobble [23]. Figure 6 demonstrates this issue: an original $42\times 42$ image (Figure 6a) is scaled by approximately $1.33\times$ to $56\times 56$ (Figure 6b), and then resized back to its original resolution (Figure 6c). Although the hard edges are preserved, the resampling process forces pixels into non-aligned integer positions, resulting in irregular block sizes. This structural degradation is irreversible; as shown in the difference map in Figure 7 (subtraction of Figure 6c from Figure 6a), the distortion introduced during the non-integer scaling persists even after returning to the original resolution.

Consequently, we can conclude that preserving the quality of pixel art requires strict adherence to both Nearest Neighbor interpolation and integer-based scaling factors. This constraint applies equally to image reduction. While reversing an integer-based upscaling (e.g., scaling by $1/3$ after a $3\times$ zoom) is mathematically lossless, arbitrary reduction factors cause significant data loss. Figure 8 highlights this contrast: reducing a $3\times$ scaled image ($126\times 126$) by a factor of 0.5 results in severe distortion (Figure 8b), whereas reducing it by the reciprocal of the enlargement factor ($1/3$) perfectly restores the original image without artifacts (Figure 8c).

In this study, we define any irreversible transformation or artifact introduced during resizing—whether blurring, shimmering, or geometric irregularity—as damage. Conversely, the property of preserving the semantic and structural identity of the original pixel art is defined as integrity.

To ensure integrity, resizing must be restricted to integer multiples or their exact reciprocals using Nearest Neighbor interpolation.

A critical challenge, however, is that pixel art distributed online is rarely in its original resolution; it is often pre-scaled by unknown integer factors for display on high-resolution screens. Naive resizing of these already-scaled images typically leads to the aforementioned damage. To address this, our approach leverages the intrinsic block size n—the fundamental structural unit of pixel art. We propose an algorithm to detect this inherent n and recover the image’s original, unscaled grid (restoration). This recovered source then serves as the optimal input for a subsequent resizing algorithm, enabling the generation of user-specified dimensions with the highest possible integrity.

4. Proposed Method

In this section, we propose a novel methodology to address the resizing issues discussed in the introduction. The remainder of this section is organized as follows. Section 4.1 first establishes the formal mathematical definition of “Block Size” (n). Based on this parameter, we conceptually define the “Block” as the structural unit derived from n. Section 4.2 details the algorithm for detecting the intrinsic block size n from an input image. Finally, Section 4.3 presents our integrity-preserving resizing algorithm, which approximates user-specified scaling factors by utilizing the detected block size and a normalized unit-grid representation.

4.1. Block Size and Block

To systematically address the resizing problem, we first establish a formal definition of the block size, which serves as the fundamental structural parameter of pixel art. Based on this parameter, we then define the block as the specific spatial region constituting the image.

Definition 1

(Block Size). Let I be a pixel art image with width W and height H. The block size n is defined as the largest positive integer that satisfies the following three conditions:

1.

Divisibility Condition:  The integer n must be a common divisor of both the image width and height. That is, there must exist positive integers w and h such that

$$W=n·w,H=n·h$$

(1)

2.

Uniformity Condition:  For all integer pairs $(i,j)$ where $0\le i<w$ and $0\le j<h$, the color values of all pixels within the corresponding $n\times n$ region must be identical. Specifically, for any coordinate $(x,y)$ satisfying

$$i·n\le x<(i+1)·n,j·n\le y<(j+1)·n$$

(2)

the pixel value $I(x,y)$ must be constant.

3.

Maximality Condition:  Among all positive integers satisfying conditions 1 and 2, n is the maximum value.

Definition 2

(Block). Given an image I with a detected block size n, a block ($B_{i,j}$) is defined as the fundamental unit region that partitions the coordinate space G. It is represented as a set of pixels indexed by integer coordinates $(i,j)$ (where $0\le i<w,0\le j<h$):

$$\begin{array}{cc}\hfill B_{i,j}=\{(x,y)\in G \mid & i·n\le x<(i+1)·n,\hfill \\ \hfill & j·n\le y<(j+1)·n\}\hfill \end{array}$$

(3)

According to this definition, a block is a square region of size $n\times n$ composed of identical pixels, and the image I can be interpreted as a grid of $w\times h$ blocks.

Figure 9 illustrates the concept of block size n applied to different images.

• Figure 9a: A $10\times 10$ image where each logical point corresponds to a single pixel. Here, $n=1$.
• Figure 9b: A $22\times 26$ image where each point corresponds to a $2\times 2$ pixel area. Since the entire grid aligns perfectly with $2\times 2$ units, $n=2$.
• Figure 9c: A $42\times 54$ image where visual elements form $3\times 3$ squares. Thus, $n=3$.

The Maximality Condition is crucial here. Theoretically, the pixels in Figure 9c could be interpreted as $1\times 1$ blocks ($n=1$) since every pixel is uniform with itself. However, because the $3\times 3$ structure is consistent and larger, $n=3$ is the valid block size that reflects the image’s true structure.

The relationship between block size and image scaling is demonstrated in Figure 10. Figure 10b ($20\times 20,n=2$) is the result of scaling Figure 10a ($10\times 10,n=1$) by a factor of 2. This implies that an image with a block size of n can be fundamentally treated as an image with $n=1$ scaled by a factor of n.

Figure 11 presents a counter-example that highlights the importance of the Divisibility Condition. This image is $20\times 21$ pixels and appears similar to Figure 10b ($n=2$). However, due to the additional row of pixels at the bottom ($y=21$), the height $H=21$ is not divisible by 2. Consequently, the condition $H=n·h$ fails for $n=2$. Therefore, despite the visual similarity to a $2\times$ scaled image, Figure 11 is mathematically classified as having a block size of $n=1$.

4.2. Block Size Detection Algorithm

Based on the definitions established in Section 4.1, we now define the algorithm to detect the intrinsic block size n of an input image.

Before detailing the procedure, it is crucial to explicitly state the operating premise of this algorithm: it assumes that the input pixel art possesses a strictly uniform block structure across the entire image. As addressed in the limitations, artworks containing mixed resolutions (non-uniform block structures or ‘Mixels’) do not possess a single global block size $n>1$. Therefore, under this algorithm, such cases are mathematically identified as having a block size of $n=1$ to preserve their irregular details without distortion.

As formalized in Definition 1, an image I with a block size of n corresponds to a structure where the fundamental unit is an $n\times n$ square. From a geometric transformation perspective, this implies that the input image I is the result of applying a uniform scaling transformation by a factor of n to an original unit-grid image (where the block size is 1px).

This geometric relationship can be rigorously expressed using homogeneous coordinates. Let the dimensions of the original unit-grid image be width w and height h. We represent these dimensions as a vector ${\mathbf{v}}_{\mathrm{orig}}$:

$${\mathbf{v}}_{\mathrm{orig}}=\left[\begin{array}{c}w\\ h\\ 1\end{array}\right]$$

(4)

The operation of scaling this image by a factor of n corresponds to multiplying ${\mathbf{v}}_{\mathrm{orig}}$ by a scaling matrix ${\mathbf{S}}_n$. The resulting vector ${\mathbf{v}}_{\mathrm{input}}$, representing the dimensions W and H of the observed input image, is derived as follows:

$${\mathbf{v}}_{\mathrm{input}}={\mathbf{S}}_n·{\mathbf{v}}_{\mathrm{orig}}=\left[\begin{array}{ccc}n& 0& 0\\ 0& n& 0\\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}w\\ h\\ 1\end{array}\right]=\left[\begin{array}{c}n·w\\ n·h\\ 1\end{array}\right]=\left[\begin{array}{c}W\\ H\\ 1\end{array}\right]$$

(5)

Equation (5) mathematically confirms the Divisibility Condition defined in Section 4.1. It demonstrates that the observed width W and height H are integer multiples of the block size n (i.e., $W=n·w$ and $H=n·h$).

Consequently, determining the block size n is equivalent to finding a value that satisfies the scaling transformation in Equation (5). This implies a critical constraint for our search algorithm: the candidate block size n must necessarily belong to the set of common divisors of the input image’s width W and height H.

By restricting the search space to the common divisors of W and H, we can significantly optimize the detection process. Furthermore, to satisfy the Maximality Condition (Definition 1, Condition 3), our algorithm iterates through the common divisors in descending order, starting from the greatest common divisor. The pseudocode for this detection algorithm is presented in Algorithm 1.   

Algorithm 1: Block size detection and image restoration algorithm.

Input: Input pixel art image I, Width W, Height H

Output: Intrinsic Block Size n, Minimized Image $I_{\min }$

    Operational Example. To elucidate the mechanics of Algorithm 1, we present a step-by-step execution using an example image. Consider the input image I shown in Figure 12a, which has dimensions $W=16$ and $H=28$. For this example, the actual intrinsic block size is $n=2$.

Initialization (Line 1): The algorithm begins by calculating the set of common divisors D for the width (16) and height (28). To satisfy the Maximality Condition, these divisors are sorted in descending order:

$$D=\{4,2,1\}$$

(6)

Iteration 1 (Candidate $\mathit{k}=\mathbf{4}$): The algorithm initiates the loop with the largest candidate, $k=4$.

1.

Downscaling (Line 3): The input image I is downscaled by a factor of 4 using Nearest Neighbor interpolation. This yields a $4\times 7$ intermediate image $I_{\min }$, as shown in Figure 12b.

2.

Restoration (Line 4): To verify integrity, $I_{\min }$ is upscaled back to the original dimensions ($16\times 28$) by a factor of 4, producing the temporary comparison image $I_{\mathrm{temp}}$ (Figure 12c).

3.

Comparison (Line 5): The algorithm compares the original input I (Figure 12a) with the reconstructed $I_{\mathrm{temp}}$ (Figure 12c). Since visual discrepancies exist (i.e., $I\ne I_{\mathrm{temp}}$), the candidate $k=4$ is rejected, and the loop proceeds to the next iteration.

Iteration 2 (Candidate $\mathit{k}=\mathbf{2}$): The algorithm tests the next largest divisor, $k=2$.

1.

Downscaling (Line 3): The input I is downscaled by a factor of 2, resulting in an $8\times 14$ image (Figure 12d). Note that this process effectively normalizes the original $2\times 2$ pixel blocks into single unit pixels ($1\times 1$).

2.

Restoration (Line 4): The image is upscaled back to $16\times 28$ by a factor of 2, generating Figure 12e.

3.

Comparison (Line 5): Upon comparing Figure 12a,e, the images are found to be identical ($I=I_{\mathrm{temp}}$). This confirms that the transformation was lossless and that the structural integrity is preserved.

Termination (Line 6): Since the equality condition is met, the algorithm terminates immediately. It returns $k=2$ as the detected block size n and Figure 12d as the normalized unit-grid image ($I_{\min }$).

Rationale for Descending Order Search. The strategy of iterating through common divisors in descending order (Line 1) is critical for strictly adhering to the Maximality Condition defined in Section 4.1. If the algorithm were to search in ascending order (starting from 1), it would invariably return $n=1$ for all images, as 1 is a universal divisor for any resolution. This would fail to capture the meaningful macro-structure of pixel art. By prioritizing the largest possible divisors, our approach ensures that the detected n represents the largest possible square that constitutes the fundamental unit of the image, thereby satisfying the formal definition of the Block.

4.3. User-Input Scale Approximation Resizing Algorithm

This section introduces a resizing algorithm designed to approximate a user-specified scaling factor while strictly preserving the structural integrity of the pixel art. The detailed procedure is presented in Algorithm 2.

The algorithm accepts the user-input image I and the desired scaling factor $S_{\mathrm{user}}$. First, it invokes Algorithm 1 (Section 4.2) to extract the intrinsic block size n and the normalized unit-grid image ($I_{\min }$).

The core of this method lies in calculating a new integer scaling factor, $S_{\mathrm{new}}$, which is applied to $I_{\min }$. The relationship is defined as follows:

$$S_{\mathrm{new}}=\mathrm{Round}(n\times S_{\mathrm{user}})$$

(7)

Here, $\mathrm{Round}(·)$ denotes rounding to the nearest integer. This formula ensures that the final image is formed by scaling the fundamental unit ($I_{\min }$) by an integer factor $S_{\mathrm{new}}$, thereby guaranteeing that the resulting block size is exactly $S_{\mathrm{new}}$ pixels.

Minimum Integrity Constraint. A critical exception handling is applied when $S_{\mathrm{new}}$ results in 0. This occurs if the user’s desired scale is too small (specifically, when $n\times S_{\mathrm{user}}<0.5$). Since a block size cannot be zero or negative, we enforce a lower bound of $S_{\mathrm{new}}=1$. This prevents the complete loss of structural information and ensures that the smallest possible representation is the unit-grid image ($I_{\min }$) itself.    

Algorithm 2: User-input scale approximation resizing algorithm.

Input: Input pixel art image I, User-specified scale factor Suser

Output: Resized Image Iout preserving integrity

Operational Example. We demonstrate this process using the image in Figure 13a. Suppose the user inputs this image with a desired scale of $S_{\mathrm{user}}=1.4$.

1.

Detection (Line 1): Algorithm 1 analyzes Figure 13a and detects an intrinsic block size of $n=2$, returning the minimized image $I_{\min }$ (Figure 13b).

2.

Approximation (Line 2): The algorithm calculates the target integer scale as follows:

$$S_{\mathrm{new}}=\mathrm{Round}(2\times 1.4)=\mathrm{Round}\left(2.8\right)=3$$

(8)

(Note: Since $S_{\mathrm{new}}=3\ne 0$, the conditional check in Lines 3–4 is bypassed.)

3.

Resizing (Lines 5–7): The minimized image $I_{\min }$ is scaled up by a factor of 3 using Nearest Neighbor interpolation.

The result, Figure 13c, effectively has a block size of 3px. When compared to the original image ($n=2$), this represents an effective scaling factor of $1.5\times$ ($3/2$). Our algorithm successfully identifies $1.5\times$ as the closest integrity-preserving scale to the user’s requested $1.4\times$ and generates the optimal output.

5. Experimental Results

In this section, we evaluate the effectiveness of the proposed resizing methodology through comprehensive comparative experiments. The primary objective of this evaluation is to verify whether the proposed algorithm, which detects the intrinsic block size n and approximates user-specified scales, successfully preserves the integrity of pixel art compared to traditional interpolation techniques. To objectively demonstrate the superiority of our approach, we conducted experiments using various pixel art samples with distinct block structures. The results are analyzed not only visually but also quantitatively using the definitions of integrity established in Section 3.

The remainder of this section is organized as follows. Section 5.1 defines the quantitative performance metrics used for evaluation: Color Loss (CL), Block Size Consistency (BSC), and reversibility (REV). Section 5.2 presents the experimental results, providing a detailed analysis of how the proposed method outperforms existing algorithms (Nearest Neighbor, Bicubic) in preserving both chromatic and structural identity. Finally, Section 5.3 discusses the limitations of the proposed method.

5.1. Performance Metrics

To objectively assess the preservation of pixel art integrity, we define three quantitative performance metrics: Color Loss (CL), Block Size Consistency (BSC), and reversibility (REV). These metrics are designed to rigorously measure the chromatic, structural, and information-preserving qualities of the resizing process.

1. Color Loss (CL). Color Loss (CL) quantifies the chromatic degradation of the resized image by measuring the proliferation of interpolation artifacts relative to the image resolution. Since pixel art relies on a strictly limited palette [1,9,24], any increase in the number of unique colors indicates the introduction of blurring or anti-aliasing artifacts.

To ensure an intuitive quantitative comparison, we normalize this metric against the total number of pixels in the resized image, bounding the value between 0% (perfect preservation) and approximately 100% (complete loss of palette integrity).

Let $C\left(I\right)$ denote the function that counts the number of unique colors in image I. For an original image $I_{\mathrm{orig}}$ and a resized image $I_{\mathrm{resized}}$ with width $W^{\prime }$ and height $H^{\prime }$, the Color Loss is defined as

$$\mathrm{CL}={\displaystyle \frac{C\left(I_{\mathrm{resized}}\right)-C\left(I_{\mathrm{orig}}\right)}{W^{\prime }·H^{\prime }}}\times 100(\%)$$

(9)

A CL of 0% indicates that the original color palette has been strictly maintained. Conversely, a higher CL value implies that a significant portion of the pixel space is occupied by interpolated colors foreign to the original artistic intent.

To visualize the impact of interpolation on chromatic integrity, we present Figure 14. Figure 14a is the original pixel art image ($n=1$) composed of a discrete set of 8 unique colors. Conversely, Figure 14b, which is scaled by a factor of $0.5\times$ using bicubic interpolation, introduces intermediate color values due to blurring artifacts. Consequently, the color count increases from 8 to 44.

Assuming the resized image has dimensions of $8\times 8$ pixels (64 pixels total), applying the defined formula yields

$${\mathrm{CL}}_{\mathrm{Figure}12}={\displaystyle \frac{44-8}{8·8}}\times 100=56.25\%$$

(10)

This value quantitatively represents that 56.25% of the image area is corrupted by chromatic artifacts, significantly damaging the pixel art’s fundamental characteristic.

2. Block Size Consistency (BSC). Block Size Consistency (BSC) evaluates the structural integrity of the resized image. It quantifies geometric distortions such as pixel wobble or shimmering, where the regular grid structure of pixel art is compromised due to non-integer scaling.

Let n be the intrinsic block size of the original image, and S be the scaling factor. The expected block size in the resized image is $n^{\prime }=\mathrm{Round}(n\times S)$. We analyze the resized image as a grid of $n^{\prime }\times n^{\prime }$ cells. A cell is considered damaged if the pixels within it are not uniform in color. The BSC is calculated as the ratio of damaged cells ($N_{\mathrm{damaged}}$) to the total number of cells ($N_{\mathrm{total}}$):

$$\mathrm{BSC}={\displaystyle \frac{N_{\mathrm{damaged}}}{N_{\mathrm{total}}}}\times 100(\%)$$

(11)

A BSC of 0% implies that all blocks maintain their correct square shape and uniformity.

Figure 15 demonstrates this metric using a BSC Visualization Filter. In this visualization, blue regions represent valid blocks (uniform color), while red regions represent damaged blocks (mixed colors). We experiment with an input image ($42\times 27$) having an intrinsic block size of $n=3$ (Figure 15a). The image is scaled by a factor of $1.14\times$ using Nearest Neighbor and Bicubic methods. As shown in Figure 15e, the $1.14\times$ Nearest Neighbor scaling causes pixel wobble, disrupting the regular grid. The filter captures this geometric distortion as red regions, resulting in a BSC error of 65.62%. Furthermore, Figure 15f shows that Bicubic interpolation destroys the block structure almost entirely due to color blending, yielding a BSC error of 94.38%. These results confirm that standard resizing methods fail to preserve structural integrity.

3. Reversibility Test (REV). The Reversibility Test (REV) assesses whether the resizing process causes permanent information loss. In the context of pixel art, a valid resizing operation should be mathematically reversible. The experimental procedure involves upscaling an original image I by a factor of S to $I^{\prime }$, and then downscaling $I^{\prime }$ by $1/S$ to restore $I^{″}$. The difference between I and $I^{″}$ is measured using the Mean Squared Error (MSE):

$$\mathrm{REV}={\displaystyle \frac{1}{W·H}}\sum _{x=0}^{W-1}\sum _{y=0}^{H-1}{\parallel I(x,y)-I^{″}(x,y)\parallel }^2$$

(12)

where W and H denote the width and height of the image, respectively. An REV value of 0 indicates perfect reversibility, confirming that the resizing process is lossless.

It is important to note that this metric is applicable only when the algorithm supports a mathematically defined inverse operation (e.g., downscaling by $1/S$), such as Nearest Neighbor or bicubic. Conversely, specialized upscalers—including Scale2x, xBRZ, Real-ESRGAN, and ITSRN—lack a paired inverse algorithm. Since substituting a standard interpolation for this missing inverse would be methodologically invalid, the REV metric for these methods is denoted as “n/a” in our results.

To empirically verify the irreversibility of traditional methods, we conduct a restoration experiment as illustrated in Figure 16.

• Column 1 (Reference): Represents the ideal reversible case. Figure 16f shows the difference map between the original image (a) and itself, resulting in an MSE of 0. This serves as the ground truth for lossless resizing.
• Column 2 (Nearest Neighbor): The original image (a) is scaled by $1.15\times$ using Nearest Neighbor to generate (b), and then restored by $1/1.15\times$ to (d). Due to the non-integer scaling, pixels are irregularly duplicated or dropped. The difference map (g) highlights significant structural misalignment, yielding a critically high MSE of 7346.91.
• Column 3 (Bicubic): The image is scaled by $1.15\times$ using Bicubic interpolation (c) and then restored (e). While the geometric distortion is less severe than Nearest Neighbor, the interpolation introduces smoothing artifacts that permanently alter the pixel values. The difference map (h) visualizes these chromatic errors, resulting in an MSE of 176.55.

These results demonstrate that standard interpolation methods cause permanent information loss during non-integer resizing, confirming the necessity for the proposed integrity-preserving algorithm.

5.2. Results and Analysis

To validate the efficacy of the proposed method, we conducted experiments using two distinct pixel art images, as shown in Figure 17. These are CC0-licensed public domain game asset sprites suitable for research. Figure 17a consists of a basic structure with an original size of $15\times 11$, a block size of 1, and a color count of 8. In contrast, Figure 17b represents a more complex structure with an original size of $42\times 27$, a block size of 3, and a color count of 6. By comparing these two inputs, we investigate how the block size influences the integrity-preserving capabilities of the proposed method versus conventional algorithms.

The first experiment, summarized in

Table 1. Experimental results using Figure 17a as the input image (original size = 15 × 11, block size = 1, color count = 8). Abbreviations: CL, Color Loss; BSC, Block Size Consistency; REV, Reversibility Test; ITSRN, Implicit Transformer Network.

Methods	Scaling Factor
	0.5	0.75	1.25	1.5	2.0	2.33	3.7
Nearest Neighbor	8 × 6 CL: 0% BSC: 0% REV: 13458	11 × 8 CL: 0% BSC: 0% REV: 10471	19 × 14 CL: 0% BSC: 0% REV: 10478	22 × 16 CL: 0% BSC: 59% REV: 10478	30 × 22 CL: 0% BSC: 0% REV: 0	35 × 26 CL: 0% BSC: 44% REV: 10738	56 × 41 CL: 0% BSC: 61% REV: 10478
Bicubic	8 × 6 CL: 73% BSC: 0% REV: 4425	11 × 8 CL: 82% BSC: 0% REV: 2662	19 × 14 CL: 77% BSC: 0% REV: 317	22 × 16 CL: 78% BSC: 97% REV: 160	30 × 22 CL: 76% BSC: 97% REV: 48	35 × 26 CL: 77% BSC: 95% REV: 14	56 × 41 CL: 74% BSC: 99% REV: 7
Scale2x [17]	n/a	n/a	n/a	n/a	30 × 22 CL: 0% BSC: 100% REV: n/a	n/a	n/a
xBRZ [18]	n/a	n/a	n/a	n/a	30 × 22 CL: 6% BSC: 100% REV: n/a	n/a	n/a
ITSRN [19]	8 × 6 CL: 83% BSC: 0% REV: n/a	11 × 8 CL: 90% BSC: 0% REV: n/a	19 × 14 CL: 81% BSC: 0% REV: n/a	22 × 16 CL: 81% BSC: 0% REV: n/a	30 × 22 CL: 79% BSC: 99% REV: n/a	35 × 26 CL: 80% BSC: 96% REV: n/a	56 × 41 CL: 78% BSC: 100% REV: n/a
Real-ESRGAN [20]	8 × 6 CL: 77% BSC: 0% REV: n/a	11 × 8 CL: 89% BSC: 0% REV: n/a	19 × 14 CL: 94% BSC: 0% REV: n/a	22 × 16 CL: 93% BSC: 100% REV: n/a	30 × 22 CL: 93% BSC: 100% REV: n/a	35 × 26 CL: 92% BSC: 100% REV: n/a	56 × 41 CL: 88% BSC: 100% REV: n/a
Proposed Method	15 × 11 CL: 0% BSC: 0% REV: 0	15 × 11 CL: 0% BSC: 0% REV: 0	15 × 11 CL: 0% BSC: 0% REV: 0	30 × 22 CL: 0% BSC: 0% REV: 0	30 × 22 CL: 0% BSC: 0% REV: 0	30 × 22 CL: 0% BSC: 0% REV: 0	60 × 44 CL: 0% BSC: 0% REV: 0

, utilized Figure 17a ($n=1$). Since a block size of 1 implies the image is composed of atomic pixels, every pixel represents a boundary potentially adjacent to a contrasting color. Consequently, bicubic interpolation yielded a consistently high Color Loss of approximately 70% regardless of the scaling factor. This indicates that standard interpolation uniformly blurs nearly the entire image area when the structural unit is minimal.

Similarly, the deep learning-based models, ITSRN and Real-ESRGAN, exhibited limitations akin to bicubic interpolation. Both models demonstrated high Color Loss across all scaling factors.

It is worth noting the characteristics of the colors generated by these models. While bicubic interpolation produces intermediate colors through mathematical averaging, deep learning models tend to infer entirely new colors based on their training data distributions. However, since the CL metric is defined to simply count the quantity of colors not present in the original palette, it does not differentiate between the subtle gradients of interpolation and the potentially distinct hues generated by deep learning inference. Thus, while the high CL values correctly indicate a violation of the original palette, the metric itself does not fully capture the qualitative nature of the chromatic shifts introduced by these data-driven approaches.

Regarding structural integrity, they yielded Block Size Consistency (BSC) values nearing 100% in most cases, indicating that the grid structure was largely destroyed. It is important to note that for scaling factors where the target block size rounds to 1 (e.g., $0.5\times$ and $0.75\times$ in Table 1), the BSC metric is mathematically 0% for all methods, including the deep learning models, because a single pixel cannot exhibit internal inconsistency. However, at scaling factors resulting in a target block size of 2 or greater, these models failed to maintain block uniformity.

In contrast, xBRZ demonstrated a significantly lower CL compared to Bicubic. This is attributable to its edge-directed logic; xBRZ preserves original colors in straight line segments and only applies interpolation to regions identified as curves, thereby minimizing palette pollution. The proposed method successfully maintained 0% CL across all metrics by adhering to integer scaling constraints.

The second experiment, shown in

Table 2. Experimental results using Figure 17b as the input image (original size = 42 × 27, block size = 3, color count = 6).

Methods	Scaling Factor
	0.5	0.75	1.25	1.5	2.0	2.33	3.7
Nearest Neighbor	21 × 14 CL: 0% BSC: 69% REV: 8151	32 × 20 CL: 0% BSC: 46% REV: 8570	52 × 34 CL: 0% BSC: 70% REV: 7347	63 × 40 CL: 0% BSC: 65% REV: 6211	84 × 54 CL: 0% BSC: 0% REV: 0	98 × 63 CL: 0% BSC: 0% REV: 0	155 × 100 CL: 0% BSC: 83% REV: 7511
Bicubic	21 × 14 CL: 40% BSC: 93% REV: 1490	32 × 20 CL: 39% BSC: 89% REV: 804	52 × 34 CL: 32% BSC: 97% REV: 122	63 × 40 CL: 27% BSC: 95% REV: 60	84 × 54 CL: 8% BSC: 98% REV: 32	98 × 63 CL: 4% BSC: 98% REV: 32	155 × 100 CL: 20% BSC: 98% REV: 4
Scale2x [17]	n/a	n/a	n/a	n/a	84 × 54 CL: 0% BSC: 65% REV: n/a	n/a	n/a
xBRZ [18]	n/a	n/a	n/a	n/a	84 × 54 CL: 1% BSC: 56% REV: n/a	n/a	n/a
ITSRN [19]	21 × 14 CL: 90% BSC: 100% REV: n/a	32 × 20 CL: 82% BSC: 99% REV: n/a	52 × 34 CL: 61% BSC: 99% REV: n/a	63 × 40 CL: 61% BSC: 99% REV: n/a	84 × 54 CL: 52% BSC: 100% REV: n/a	98 × 63 CL: 53% BSC: 100% REV: n/a	155 × 100 CL: 50% BSC: 100% REV: n/a
Real-ESRGAN [20]	21 × 14 CL: 89% BSC: 95% REV: n/a	32 × 20 CL: 90% BSC: 93% REV: n/a	52 × 34 CL: 89% BSC: 94% REV: n/a	63 × 40 CL: 88% BSC: 94% REV: n/a	84 × 54 CL: 85% BSC: 97% REV: n/a	98 × 63 CL: 83% BSC: 96% REV: n/a	155 × 100 CL: 75% BSC: 97% REV: n/a
Proposed Method	28 × 18 CL: 0% BSC: 0% REV: 0	28 × 18 CL: 0% BSC: 0% REV: 0	56 × 36 CL: 0% BSC: 0% REV: 0	70 × 45 CL: 0% BSC: 0% REV: 0	84 × 54 CL: 0% BSC: 0% REV: 0	98 × 63 CL: 0% BSC: 0% REV: 0	154 × 99 CL: 0% BSC: 0% REV: 0

using Figure 17b ($n=3$), revealed distinct behaviors due to the larger structural unit. First, the overall CL values for Bicubic interpolation decreased significantly compared to Experiment 1. This reduction is explained by the area-to-perimeter ratio of the blocks. In a $3\times 3$ block, the central pixels are surrounded by identical neighbors, creating a “safe zone” protected from color blending. Unlike the $n=1$ case where every pixel is an edge, the $n=3$ case restricts interpolation artifacts to the block boundaries, preserving the chromatic integrity of the inner regions.

Consequently, Bicubic CL dropped notably to 8% at 2.0× and further to 4% at 2.33×. This occurs because these specific factors map the original $3\times 3$ blocks to larger, near-integer grids (e.g., $6\times 6$ at 2.0×, ≈$7\times 7$ at 2.33×). As the target block size increases, the proportion of preserved inner pixels grows relative to the affected boundary pixels, drastically reducing the overall color loss.

xBRZ exhibited exceptional performance in this scenario, achieving a negligible CL of approximately 1%, confirming its effectiveness in handling larger coherent regions.

In contrast to these traditional approaches, a distinct phenomenon was observed with Real-ESRGAN, highlighting the trade-off between “depixelization” and integrity. Due to the model’s objective to restore realistic details, it inherently removes pixel art attributes, generating a completely new image representation. As evident in Table 2, the square blocks representing flower petals in the original image are reinterpreted as diagonal lines or smooth curves at scaling factors of $1.25\times$ or higher. This results in the complete removal of the visual cues that identify the object as a flower in the pixel art style. While the original rectangular structure is maintained during downscaling ($<1.0\times$) due to the absolute lack of pixels to form curves, significant distortion occurs during upscaling. This transformation confirms that while the output may look smooth, it fails to preserve the grid-based identity of the artwork.

Most importantly, the proposed method demonstrated superior flexibility in this scenario. Leveraging the theoretical principle presented in

Table 3. A table illustrating the concept of extending integer multiple enlargements using block size.

Block Size	Scaling Factor
	1.0	2.0	3.0
1	1	2	3
2	${\displaystyle \frac{1}{2}}$	${\displaystyle \frac{2}{2}}=1$	${\displaystyle \frac{3}{2}}$
3	${\displaystyle \frac{1}{3}}$	${\displaystyle \frac{2}{3}}$	${\displaystyle \frac{3}{3}}=1$
⋮	⋮	⋮	⋮
n	${\displaystyle \frac{1}{n}}$	${\displaystyle \frac{2}{n}}$	${\displaystyle \frac{3}{n}}$

, where valid scaling factors are defined as $S=k/n$ ($k\in {\mathbb{Z}}^{+}$), the larger block size ($n=3$) expanded the range of integrity-preserving scales to include fractional values (e.g., $1/3,2/3$). By detecting the optimal block size, the proposed method achieved perfect integrity (CL: 0%, BSC: 0%, REV: 0) even at fractional targets like 0.5 and 0.75, proving that a larger block size allows for a more versatile set of artifact-free resizing options compared to the $n=1$ baseline.

5.3. Limitations

As demonstrated in Table 1 and Table 2, the proposed method outperformed conventional algorithms across all quantitative metrics, successfully executing resizing that strictly preserves structural integrity. However, despite this proven efficacy, several limitations arise from the mathematical assumptions and the specific nature of the datasets used.

First, the experiments utilized strictly uniform public domain assets (Figure 17) to validate the algorithm. However, the method relies on the premise that the input pixel art possesses a strictly uniform block structure. This assumption becomes a critical limitation when processing inputs where this uniformity is compromised—whether due to artistic intent, such as hybrid pixel art containing mixed resolutions (‘Mixels’), or due to quality degradation, such as lossy compression artifacts (e.g., JPEG) or structural damage from repeated improper resizing. In such scenarios, where block boundaries are blurred or multiple block sizes coexist, a global common divisor $n>1$ does not mathematically exist. Consequently, our algorithm detects the image as a unit-grid structure ($n=1$), failing to leverage the optimization benefits of block-based processing. However, it is worth noting that in the context of traditional pixel art, such non-uniformity—whether from mixed resolutions or compression artifacts—is categorized as a visual artifact or a structural inconsistency that violates the grid-based aesthetic [25], partially justifying this limitation.

Second, although the proposed method achieved perfect scores across all scaling factors in the experiments, this performance is inherently restricted to isotropic scaling (axis-aligned resizing). It is incapable of handling geometric transformations such as rotations, non-uniform stretching, or perspective projections, as these operations disrupt the orthogonal grid structure required for integer-based block detection.

Third, due to the discrete nature of the grid shown in Table 3, the algorithm employs a rounding operation to determine the new block size ($S_{new}$). As a result, the final scaling ratio may deviate noticeably from the user-specified floating-point value, particularly when the target scale change is small relative to the intrinsic block size n.

Fourth, while the detection speed was negligible for the small sample images ($15\times 11$, $42\times 27$), the intrinsic block size detection algorithm requires iterative resizing operations and full-image comparisons. This process may become a computational bottleneck when applied to very large images or in scenarios requiring real-time processing.

Finally, the comparison with Real-ESRGAN and xBRZ in the experiments reveals the inherent scope of our evaluation metrics. As observed in Table 2, smoothing-based methods or generative models yielded high error rates in Color Loss (CL) and Block Size Consistency (BSC). This is because these metrics are specifically designed to quantify fidelity to the pixel art medium—characterized by sharp edges and a discrete palette. Consequently, results that are subjectively perceived as visually pleasing by users preferring a modernized or vectorized aesthetic are penalized. Our study interprets these quantitative gaps not as a failure of those algorithms but as a quantification of the stylistic shift away from the original grid-based aesthetic, highlighting that our metrics prioritize structural preservation over perceptual smoothness.

6. Conclusions

This study addressed the fundamental problem of visual degradation that occurs during the resizing of pixel art, a medium defined by its distinct grid-based aesthetic. To solve the issues of color bleeding and structural distortion common in conventional interpolation methods, we introduced the novel concepts of block size n and proposed a two-stage methodology: an automatic block size detection algorithm and an integrity-preserving resizing algorithm.

The proposed method fundamentally differs from traditional image processing techniques that rely on spatial approximation. Instead, it treats pixel art as a discrete structure composed of logical blocks. By accurately identifying the atomic block size n and normalizing the image to a unit block structure ($n=1$), the algorithm guarantees that scaling operations remain within the mathematically safe domain. The experimental results confirmed that this approach completely prevents Color Loss (CL) and Block Size Consistency (BSC) across various scaling factors.

The significance of this research lies in its establishment of a structure-aware framework for discrete image processing. We demonstrated that the range of integrity-preserving scaling factors, S, is not limited to integers but expands to rational numbers defined by $S=k/n$. This finding implies that as modern pixel art adopts higher resolutions (larger n), the flexibility of lossless resizing increases proportionally. Moreover, integrating this block-reduction technique with existing specialized interpolation algorithms, such as Scale2x, presents a promising avenue to overcome their fixed-scale limitations (e.g., $2\times$, $3\times$). By serving as a pre-processor that restores the unit grid, our method maximizes the versatility of pixel art processing pipelines.

Future research will focus on expanding the theoretical scope of discrete image processing to address the current limitations regarding non-uniform structures. A critical objective is the development of a restoration algorithm capable of reconstructing the original block structure from inputs damaged by improper resizing or compression. Additionally, developing an adaptive local block detection algorithm that can accommodate mixed resolutions (‘Mixels’) represents a valuable research direction to overcome the dependency on global block uniformity. We also plan to optimize the computational efficiency of the detection algorithm to mitigate the bottleneck of iterative processing. Furthermore, we aim to address the geometric limitations by exploring structure-aware rotation techniques, thereby enhancing the versatility of the proposed framework.