Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1.                    ==========================================
  2.                    The Scale2x, Scale3x and Scale4x algorithm
  3.                    ==========================================
  4.  
  5.  
  6. SCALE2X ALGORITHM
  7. =================
  8.  
  9. The effect works repeating a computation pattern for every
  10. pixel of the original image.
  11. The pattern starts from a square of 9 pixels and expands the
  12. central pixel computing 4 new pixels.
  13.  
  14. Starting from this pattern :
  15.  
  16.     A B C
  17.     D E F
  18.     G H I
  19.  
  20. The central pixel E is expanded in 4 new pixels:
  21.  
  22.     E0 E1
  23.     E2 E3
  24.  
  25. with these rules (in C language) :
  26.  
  27.     E0 = D == B && B != F && D != H ? D : E;
  28.     E1 = B == F && B != D && F != H ? F : E;
  29.     E2 = D == H && D != B && H != F ? D : E;
  30.     E3 = H == F && D != H && B != F ? F : E;
  31.  
  32. which can be rewritten as :
  33.  
  34.     E0 = D == B && B != H && D != F ? D : E;
  35.     E1 = B == F && B != H && D != F ? F : E;
  36.     E2 = D == H && B != H && D != F ? D : E;
  37.     E3 = H == F && B != H && D != F ? F : E;
  38.  
  39. and optimized as:
  40.  
  41.     if (B != H && D != F) {
  42.         E0 = D == B ? D : E;
  43.         E1 = B == F ? F : E;
  44.         E2 = D == H ? D : E;
  45.         E3 = H == F ? F : E;
  46.     } else {
  47.         E0 = E;
  48.         E1 = E;
  49.         E2 = E;
  50.         E3 = E;
  51.     }
  52.  
  53. The image border is computed reusing the value of the nearest pixel
  54. on the border when the value of a pixel over the border is required.
  55.  
  56.  
  57. SCALE3X ALGORITHM
  58. =================
  59.  
  60. Starting from this pattern :
  61.  
  62.     A B C
  63.     D E F
  64.     G H I
  65.  
  66. The central pixel E is expanded in 9 new pixels:
  67.  
  68.     E0 E1 E2
  69.     E3 E4 E5
  70.     E6 E7 E8
  71.  
  72. with these rules (in C language) :
  73.  
  74.     E0 = D == B && B != F && D != H ? D : E;
  75.     E1 = (D == B && B != F && D != H && E != C) || (B == F && B != D && F != H && E != A) ? B : E;
  76.     E2 = B == F && B != D && F != H ? F : E;
  77.     E3 = (D == B && B != F && D != H && E != G) || (D == H && D != B && H != F && E != A) ? D : E;
  78.     E4 = E
  79.     E5 = (B == F && B != D && F != H && E != I) || (H == F && D != H && B != F && E != C) ? F : E;
  80.     E6 = D == H && D != B && H != F ? D : E;
  81.     E7 = (D == H && D != B && H != F && E != I) || (H == F && D != H && B != F && E != G) ? H : E;
  82.     E8 = H == F && D != H && B != F ? F : E;
  83.  
  84. and optimized as:
  85.  
  86.     if (B != H && D != F) {
  87.         E0 = D == B ? D : E;
  88.         E1 = (D == B && E != C) || (B == F && E != A) ? B : E;
  89.         E2 = B == F ? F : E;
  90.         E3 = (D == B && E != G) || (D == H && E != A) ? D : E;
  91.         E4 = E;
  92.         E5 = (B == F && E != I) || (H == F && E != C) ? F : E;
  93.         E6 = D == H ? D : E;
  94.         E7 = (D == H && E != I) || (H == F && E != G) ? H : E;
  95.         E8 = H == F ? F : E;
  96.     } else {
  97.         E0 = E;
  98.         E1 = E;
  99.         E2 = E;
  100.         E3 = E;
  101.         E4 = E;
  102.         E5 = E;
  103.         E6 = E;
  104.         E7 = E;
  105.         E8 = E;
  106.     }
  107.  
  108.  
  109. SCALE4X ALGORITHM
  110. =================
  111.  
  112. The Scale4x effect is simply the Scale2x effect applied two times.
  113.