API tools faq
paste
mcgluszak

[Author: Caesar] Caesar's Graphics Toolkit ze spisem metod

mcgluszak
Jul 31st, 2011
121
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Ruby 35.65 KB | None | 0 0
raw download clone embed print report
  1. #==============================================================================
  2. # CAESAR'S GRAPHICS TOOLKIT
  3. #-=-=-=-=-=--=-=-=-=-=--=-=-=-=-=--=-=-=-=-=--=-=-=-=-=--=-=-=-=-=--=-=-=-=-=-=
  4. # Autor: Caesar
  5. #-=-=-=-=-=--=-=-=-=-=--=-=-=-=-=--=-=-=-=-=--=-=-=-=-=--=-=-=-=-=--=-=-=-=-=-=
  6. # Instrukcja:
  7. #  draw_line(x1, y1, x2, y2, color, stroke=1)
  8. #  draw_circle(cx, cy, radius, color, stroke=1)
  9. #  fill_circle(cx, cy, radius, color)
  10. #  draw_ellipse(cx, cy, a, b, color, stroke=1)
  11. #  ellipse_footprints(cx, cy, x, y, color, stroke=1)
  12. #  fill_ellipse(cx, cy, a, b, color)
  13. #  draw_oval(x, y, width, height, color, stroke=1)
  14. #  fill_oval(x, y, width, height, color)
  15. #  draw_rect(x, y, width, height, color, stroke=1)
  16. #  draw_3d_rect(x, y, width, height, color, raised=true, stroke=1)
  17. #  draw_frame_rect(x, y, width, height, color, stroke=3, brighter=true)
  18. #  draw_round_rect(x, y, width, height, b, color, stroke=1)
  19. #  fill_round_rect(x, y, width, height, b, color)
  20. #  draw_polygon(color, stroke, *vertices)
  21. #  draw_regular_polygon(cx, cy, n, radius, color, stroke=1)
  22. #  draw_shadow_text(x, y, width, height, str, align=0)
  23. #  vertical_flip
  24. #  vertical_flip!
  25. #  horizontal_filp
  26. #  horizontal_filp!
  27. #  negative
  28. #  negative!
  29. #  grayscale
  30. #  grayscale!
  31. #  pixelize(factor=2)
  32. #  pixelize!(factor=2)
  33. #  blur(f=1)
  34. #  blur!(f=1)
  35. #  shake(d=1, horizontal=true, vertical=true)
  36. #  shake!(d=1, horizontal=true, vertical=true)
  37. #  change_brightness(b)
  38. #  change_contrast(contrast)
  39. #  threshold(s=128)
  40. #  threshold!(s=128)
  41. #  emboss
  42. #  emboss!
  43. #  scale(factor_x, factor_y=factor_x)
  44. #  scale_to(width, height)
  45. #  zoom_area(x, y, width, height)
  46. #  zoom_area!(x, y, width, height)
  47. #  change_opacity(opacity)
  48. #  fill_rect_horizontal_gradient(x, y, width, height, color1, color2)
  49. #  fill_rect_vertical_gradient(x, y, width, height, color1, color2)
  50. #  swap_colors(order)
  51. #  swap_colors!(order)
  52. #  replace_colors(red, green, blue, alpha, red2, green2, blue2, alpha2)
  53. #  replace_colors!(red, green, blue, alpha, red2, green2, blue2, alpha2)
  54. #  area(x, y, width, height)
  55. #  average_color(x, y, width, height)
  56. #-=-=-=-=-=--=-=-=-=-=--=-=-=-=-=--=-=-=-=-=--=-=-=-=-=--=-=-=-=-=--=-=-=-=-=-=
  57. class Bitmap
  58.   #>>>>>>>>>>>>>>>>>>>
  59.   # Mit dem DDA-Algorithmus (Digital Differential Analyzer)
  60.   # werden zwei Punkte (x1, y1) und (x2, y2) miteineander
  61.   # verbunden.
  62.   # -- color: Farbe
  63.   # -- stroke (1): Linienstärke
  64.   #<<<<<<<<<<<<<<<<<<<
  65.   def draw_line(x1, y1, x2, y2, color, stroke=1)
  66.     return if stroke <= 0
  67.     if x2 < x1
  68.       temp = x2
  69.       x2 = x1
  70.       x1 = temp
  71.       temp = y2
  72.       y2 = y1
  73.       y1 = temp
  74.     end
  75.     length = x2-x1
  76.     length = Math.abs(y2-y1) if length < Math.abs(y2-y1)
  77.     x_increment =(x2-x1).to_f / length
  78.     y_increment = (y2-y1).to_f / length
  79.     x = x1
  80.     y = y1
  81.     s = stroke.to_f / 2
  82.     if x == x2
  83.       fill_rect(x-s, [y1, y2].min, s+s, Math.abs(y2-y1), color)
  84.     end
  85.     while x < x2
  86.       fill_rect(x-s, y-s, s+s, s+s, color)
  87.       x += x_increment
  88.       y += y_increment
  89.     end
  90.   end
  91.   #--------------
  92.   #>>>>>>>>>>>>>>>>>>>
  93.   # Mit dem Bresenham-Algorithmus wird ein Kreis um den Mittelpunkt
  94.   # (cx, cy) gezeichnet.
  95.   # -- radius: Radius
  96.   # -- color: Farbe
  97.   # -- stroke (1): Linienstärke
  98.   #<<<<<<<<<<<<<<<<<<<
  99.   def draw_circle(cx, cy, radius, color, stroke=1)
  100.     return if stroke <= 0
  101.     x = 0
  102.     y = radius
  103.     d = radius-1
  104.     while y >= x
  105.       s = stroke.to_f / 2
  106.       fill_rect(cx+x-s, cy+y-s, s+s, s+s, color) # footprints
  107.       fill_rect(cx+x-s, cy-y-s, s+s, s+s, color)
  108.       fill_rect(cx-x-s, cy+y-s, s+s, s+s, color)
  109.       fill_rect(cx-x-s, cy-y-s, s+s, s+s, color)
  110.       fill_rect(cx+y-s, cy+x-s, s+s, s+s, color)
  111.       fill_rect(cx-y-s, cy+x-s, s+s, s+s, color)
  112.       fill_rect(cx+y-s, cy-x-s, s+s, s+s, color)
  113.       fill_rect(cx-y-s, cy-x-s, s+s, s+s, color)
  114.       return if y == x
  115.       if d < 0
  116.         d += 2*x + 3
  117.       else
  118.         y -= 1
  119.         d += 2*x - 2*y + 5
  120.       end
  121.       x += 1
  122.     end
  123.   end
  124.   #--------------
  125.   #>>>>>>>>>>>>>>>>>>>>
  126.   # Zeichnet einen gefĂźllten Kreis um den Mittelpunkt (cxcy).
  127.   # -- radius: Radius
  128.   # -- color: Farbe
  129.   #<<<<<<<<<<<<<<<<<<
  130.   def fill_circle(cx, cy, radius, color)
  131.     x = 0
  132.     y = radius
  133.     d = radius-1
  134.     while y >= x
  135.       fill_rect(cx-x, cy-y, 2*x, 1, color)
  136.       fill_rect(cx-y, cy-x, 2*y, 1, color)
  137.       fill_rect(cx-x, cy+y, 2*x, 1, color)
  138.       fill_rect(cx-y, cy+x, 2*y, 1, color)
  139.       return if y == x
  140.       if d < 0
  141.         d += 2*x + 3
  142.       else
  143.         y -= 1
  144.         d += 2*x - 2*y + 5
  145.       end
  146.       x += 1
  147.     end
  148.   end
  149.   #--------------
  150.   #>>>>>>>>>>>>>>>>>>>
  151.   # Zeichnet eine Ellipse um den Mittelpunkt (cx, cy) mit den Radien
  152.   # a und b.
  153.   # -- color: Farbe
  154.   # -- stroke (1): Linienstärke
  155.   #<<<<<<<<<<<<<<<<<<<
  156.   def draw_ellipse(cx, cy, a, b, color, stroke=1)
  157.     return if stroke <= 0
  158.     x = 0
  159.     y = b
  160.     d1 = b*b-a*a*b-(a*a.to_f/4)
  161.     ellipse_footprints(cx, cy, x, y, color, stroke)
  162.     while( a*a*(y-0.5) > b*b*(x-1))
  163.       if d1 < 0
  164.         d1 += b*b*(2*x+3)
  165.       else
  166.         d1 += (b*b*(2*x+3)+a*a*(-2*y+2))
  167.         y -= 1
  168.       end
  169.       x += 1
  170.       ellipse_footprints(cx, cy, x, y, color, stroke)
  171.     end
  172.     d2 = b*b*(x+0.5)*(x+0.5)+a*a*(y-1)*(y-1)-a*a*b*b
  173.     while(y > 0)
  174.       if d2 < 0
  175.         d2 += b*b*(2*x+2)+a*a*(-2*y+3)
  176.         x += 1
  177.       else
  178.         d2 += a*a*(-2*y+3)
  179.       end
  180.       y -= 1
  181.       ellipse_footprints(cx, cy, x, y, color, stroke)
  182.     end
  183.   end
  184.   #----
  185.   def ellipse_footprints(cx, cy, x, y, color, stroke=1)
  186.     s = stroke.to_f / 2
  187.     fill_rect(cx+x-s, cy+y-s, s+s, s+s, color)
  188.     fill_rect(cx+x-s, cy-y-s, s+s, s+s, color)
  189.     fill_rect(cx-x-s, cy+y-s, s+s, s+s, color)
  190.     fill_rect(cx-x-s, cy-y-s, s+s, s+s, color)
  191.   end
  192.   #--------------
  193.   #>>>>>>>>>>>>>>>>>>>
  194.   # Zeichnet eine gefĂźllte Ellipse um den Mittelpunkt (cx, cy) mit den
  195.   # Radien a und b.
  196.   # -- color: Farbe
  197.   #<<<<<<<<<<<<<<<<<<<
  198.   def fill_ellipse(cx, cy, a, b, color)
  199.     x = 0
  200.     y = b
  201.     d1 = b*b-a*a*b-(a*a.to_f/4)
  202.     fill_rect(cx-x, cy-y, 2*x, 1, color)
  203.     fill_rect(cx-x, cy+y, 2*x, 1, color)
  204.     while( a*a*(y-0.5) > b*b*(x-1))
  205.       if d1 < 0
  206.         d1 += b*b*(2*x+3)
  207.       else
  208.         d1 += (b*b*(2*x+3)+a*a*(-2*y+2))
  209.         y -= 1
  210.       end
  211.       x += 1
  212.       fill_rect(cx-x, cy-y, 2*x, 1, color)
  213.       fill_rect(cx-x, cy+y, 2*x, 1, color)
  214.     end
  215.     d2 = b*b*(x+0.5)*(x+0.5)+a*a*(y-1)*(y-1)-a*a*b*b
  216.     while(y > 0)
  217.       if d2 < 0
  218.         d2 += b*b*(2*x+2)+a*a*(-2*y+3)
  219.         x += 1
  220.       else
  221.         d2 += a*a*(-2*y+3)
  222.       end
  223.       y -= 1
  224.       fill_rect(cx-x, cy-y, 2*x, 1, color)
  225.       fill_rect(cx-x, cy+y, 2*x, 1, color)
  226.     end
  227.   end
  228.   #--------------
  229.   #>>>>>>>>>>>>>>>>>>>
  230.   # Zeichnet den Kreis oder die Ellipse, die dem Rechteck
  231.   # einbeschrieben ist.
  232.   # -- x, y, width, height: Rechteck
  233.   # -- color: Farbe
  234.   # -- stroke (1): Linienstärke
  235.   #<<<<<<<<<<<<<<<<<<<
  236.   def draw_oval(x, y, width, height, color, stroke=1)
  237.     if width == height
  238.       return draw_circle(x + width/2, y + height/2, width/2, color, stroke)
  239.     end
  240.     draw_ellipse(x + width/2, y + height/2, width/2, height/2, color, stroke)
  241.   end
  242.   #--------------
  243.   #>>>>>>>>>>>>>>>>>>>
  244.   # Zeichnet den Kreis oder die Ellipse, die dem Rechteck
  245.   # einbeschrieben ist, gefĂźllt.
  246.   # -- x, y, width, height: Rechteck
  247.   # -- color: Farbe
  248.   #<<<<<<<<<<<<<<<<<<<
  249.   def fill_oval(x, y, width, height, color)
  250.     return fill_circle(x + width/2, y + height/2, width/2, color) if width == height
  251.     fill_ellipse(x + width/2, y + height/2, width/2, height/2, color)
  252.   end
  253.   #--------------
  254.   #>>>>>>>>>>>>>>>>>>>
  255.   # Zeichent ein Rechteck.
  256.   # -- x, y, width, height: Rechteck
  257.   # -- color: Farbe
  258.   # -- stroke (1): Linienstärke
  259.   #<<<<<<<<<<<<<<<<<<<
  260.   def draw_rect(x, y, width, height, color, stroke=1)
  261.     return if stroke <= 0
  262.     #~~~~~rekursiv~~~~~
  263.     #fill_rect(x, y, width, 1, color)
  264.     #fill_rect(x, y, 1, height, color)
  265.     #fill_rect(x+width-1, y, 1, height, color)
  266.     #fill_rect(x, y+height-1, width, 1, color)
  267.     #draw_rect(x+1, y+1, width-2, height-2, color, stroke-1)
  268.     #~~~~nicht rekursiv~~~~
  269.     fill_rect(x, y, width, stroke, color)
  270.     fill_rect(x, y, stroke, height, color)
  271.     fill_rect(x+width-stroke, y, stroke, height, color)
  272.     fill_rect(x, y+height-stroke, width, stroke, color)
  273.   end
  274.   #-------------
  275.   #>>>>>>>>>>>>>>>>>>>
  276.   # Zeichnet ein Rechteck mit einem speziellen "3D-Effekt".
  277.   # -- x, y, width, height: Rechteck
  278.   # -- color: Farbe
  279.   # -- raised (true): gibt an, ob das Rechteck hĂśher (true) oder tiefer (false)
  280.   #     gezeichnet wird.
  281.   # -- stroke (1): Linienstärke
  282.   #<<<<<<<<<<<<<<<<<<<
  283.   def draw_3d_rect(x, y, width, height, color, raised=true, stroke=1)
  284.     return if stroke <= 0
  285.     if raised
  286.       color1 = color.brighter
  287.       color2 = color.darker
  288.     else
  289.       color1 = color.darker
  290.       color2 = color.brighter
  291.     end
  292.     fill_rect(x, y, width, 1, color1)
  293.     fill_rect(x, y, 1, height, color1)
  294.     fill_rect(x+width-1, y, 1, height, color2)
  295.     fill_rect(x, y+height-1, width, 1, color2)
  296.     draw_3d_rect(x+1, y+1, width-2, height-2, color, raised, stroke-1)
  297.   end
  298.   #---------------
  299.   #>>>>>>>>>>>>>>>>>>>
  300.   # Zeichnet ein dickes Rechteck mit einem FarbĂźbergang von auĂ?en
  301.   # nach innen.
  302.   # -- x, y, width, height: Rechteck
  303.   # -- color: Farbe auĂ?en
  304.   # -- stroke (3): Linienstärke
  305.   # -- brighter (true): FarbĂźbergang nach innen heller (true) oder dunkler (false)
  306.   #<<<<<<<<<<<<<<<<<<<
  307.   def draw_frame_rect(x, y, width, height, color, stroke=3, brighter=true)
  308.     return if stroke <= 0
  309.     fill_rect(x, y, width, 1, color)
  310.     fill_rect(x, y, 1, height, color)
  311.     fill_rect(x+width-1, y, 1, height, color)
  312.     fill_rect(x, y+height-1, width, 1, color)
  313.     next_color = brighter ? color.brighter : color.darker
  314.     draw_frame_rect(x+1, y+1, width-2, height-2, next_color, stroke-1, brighter)
  315.   end
  316.   #---------------
  317.   #>>>>>>>>>>>>>>>>>>>
  318.   # Zeichnet ein Rechteck mit abgerundeten Ecken.
  319.   # -- x, y, width, height: Rechteck
  320.   # -- b: gibt an, wie rund die Ecken sind (Radius der Viertelkreise an den Ecken)
  321.   # -- color: Farbe
  322.   # -- stroke (1): Linienstärke
  323.   #<<<<<<<<<<<<<<<<<<<
  324.   def draw_round_rect(x, y, width, height, b, color, stroke=1)
  325.     fill_rect(x+b, y, width-b-b, stroke, color)
  326.     fill_rect(x, y+b, stroke, height-b-b, color)
  327.     fill_rect(x+width-stroke, y+b, stroke, height-b-b, color)
  328.     fill_rect(x+b, y+height-stroke, width-b-b, stroke, color)
  329.     circle = Bitmap.new(b+b, b+b)
  330.     circle.draw_oval(0, 0, b+b, b+b, color, stroke)
  331.     blt(x, y, circle.area(0, 0, b, b), Rect.new(0, 0, b, b))
  332.     blt(x+width-b, y, circle.area(b, 0, b, b), Rect.new(0, 0, b, b))
  333.     blt(x+width-b, y+height-b, circle.area(b, b, b, b), Rect.new(0, 0, b, b))
  334.     blt(x, y+height-b, circle.area(0, b, b, b), Rect.new(0, 0, b, b))
  335.   end
  336.   #---------------
  337.   #>>>>>>>>>>>>>>>>>>>
  338.   # Zeichnet ein gefĂźlltes Rechteck mit abgerundeten Ecken.
  339.   # -- x, y, width, height: Rechteck
  340.   # -- b: gibt an, wie rund die Ecken sind (Radius der Viertelkreise an den Ecken)
  341.   # -- color: Farbe
  342.   # -- stroke (1): Linienstärke
  343.   #<<<<<<<<<<<<<<<<<<<
  344.   def fill_round_rect(x, y, width, height, b, color)
  345.     fill_rect(x, y+b, width, height-b-b, color)
  346.     fill_rect(x+b, y, width-b-b, b, color)
  347.     fill_rect(x+b, y+height-b, width-b-b, b, color)
  348.     circle = Bitmap.new(b+b, b+b)
  349.     circle.fill_oval(0, 0, b+b, b+b, color)
  350.     blt(x, y, circle.area(0, 0, b, b), Rect.new(0, 0, b, b))
  351.     blt(x+width-b, y, circle.area(b, 0, b, b), Rect.new(0, 0, b, b))
  352.     blt(x+width-b, y+height-b, circle.area(b, b, b, b), Rect.new(0, 0, b, b))
  353.     blt(x, y+height-b, circle.area(0, b, b, b), Rect.new(0, 0, b, b))
  354.   end
  355.   #---------------
  356.   #>>>>>>>>>>>>>>>>>>>
  357.   # Zeichnet ein Polygon (Vieleck).
  358.   # -- color: Farbe
  359.   # -- stroke: Linienstärke
  360.   # -- *vertices: Eckpunkte als Arrays der GrĂśĂ?e 2 fĂźr x- und y-Koordinaten
  361.   # Ein Aufruf der Methode kĂśnnte z.B. so aussehen:
  362.   # draw_polygon(Color.black, 2, [0, 0], [30, 10], [300, 100], [200, 40], [30, 50])
  363.   #<<<<<<<<<<<<<<<<<<<
  364.   def draw_polygon(color, stroke, *vertices)
  365.     if vertices[0].size > 2
  366.       vertices = vertices[0]
  367.     end
  368.     return if stroke <= 0 or vertices.size <= 2
  369.     count = vertices.size
  370.     for i in -1..count-2
  371.       x1, y1 = vertices[i]
  372.       x2, y2 = vertices[i+1]
  373.       draw_line(x1, y1, x2, y2, color, stroke)
  374.     end
  375.   end
  376.   #---------------
  377.   # todo: gefĂźlltes Polygon zeichnen, ich habe keinen effezienten Algorithmus
  378.   # finden kĂśnnen.
  379.   #---------------
  380.   #>>>>>>>>>>>>>>>>>>>
  381.   # Zeichnet ein regelmäĂ?iges Vieleck um den Mittelpunkt (cx, cy).
  382.   # -- n: Anzahl der Ecken
  383.   # -- radius: Radius
  384.   # -- color: Farbe
  385.   # -- stroke (1): Linienstärke
  386.   #<<<<<<<<<<<<<<<<<<<
  387.   def draw_regular_polygon(cx, cy, n, radius, color, stroke=1)
  388.     return if stroke <= 0 or n <= 2
  389.     phi  = 0
  390.     dphi = 2 * Math::PI / n
  391.     vertices = []
  392.     n.times do
  393.       x = radius*Math.cos(phi) + cx
  394.       y = radius*Math.sin(phi) + cy
  395.       vertices.push([x.to_i, y.to_i])
  396.       phi += dphi
  397.     end
  398.     draw_polygon(color, stroke, vertices)
  399.   end
  400.   #---------------
  401.   #>>>>>>>>>>>>>>>>>>>
  402.   # Zeichnet einen Text mit einem netten Schatteneffekt.
  403.   # -- x, y, width, height: Rechteck
  404.   # -- str: Text
  405.   # -- align (0): Ausrichtung, 0 = linksbĂźndig, 1 = zentriert, 2 = rechtsbĂźndig
  406.   #<<<<<<<<<<<<<<<<<<<
  407.   def draw_shadow_text(x, y, width, height, str, align=0)
  408.     color = font.color.dup
  409.     font.color = Color.new(192, 192, 192, 156)
  410.     draw_text(x+2, y+2, width, height, str, align)
  411.     font.color = color
  412.     draw_text(x, y, width, height, str, align)
  413.   end
  414.   #-------------
  415.   #>>>>>>>>>>>>>>>>>>>
  416.   # Gibt die Bitmap vertikal gespiegelt zurĂźck.
  417.   #<<<<<<<<<<<<<<<<<<<
  418.   def vertical_flip
  419.     buffer = Bitmap.new(width, height)
  420.     for x in 0..width
  421.       for y in 0..height
  422.         pixel = get_pixel(x, y)
  423.         buffer.set_pixel(x, height-y, pixel)
  424.       end
  425.     end
  426.     return buffer
  427.   end
  428.   #-------------
  429.   #>>>>>>>>>>>>>>>>>>
  430.   # Spiegelt die Bitmap vertikal.
  431.   #<<<<<<<<<<<<<<<<<<
  432.   def vertical_flip!
  433.     buffer = vertical_flip
  434.     clear
  435.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  436.   end
  437.   #-------------
  438.   #>>>>>>>>>>>>>>>>>>>
  439.   # Gibt die Bitmap horizontal gespiegelt zurĂźck.
  440.   #<<<<<<<<<<<<<<<<<<<
  441.   def horizontal_flip
  442.     buffer = Bitmap.new(width, height)
  443.     for x in 0..width
  444.       for y in 0..height
  445.         pixel = get_pixel(x, y)
  446.         buffer.set_pixel(width-x, y, pixel)
  447.       end
  448.     end
  449.     return buffer
  450.   end
  451.   #-------------
  452.   #>>>>>>>>>>>>>>>>>>
  453.   # Spiegelt die Bitmap horizontal.
  454.   #<<<<<<<<<<<<<<<<<<
  455.   def horizontal_flip!
  456.     buffer = horizontal_flip
  457.     clear
  458.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  459.   end
  460.   #-------------
  461.   #>>>>>>>>>>>>>>>>>>>
  462.   # Gibt das Negativ der Bitmap, d.h. mit allen Farben umgekehrt, zurĂźck.
  463.   #<<<<<<<<<<<<<<<<<<<
  464.   def negative
  465.     # Look Up Table
  466.     lut = Array.new(256)
  467.     for i in 0..255
  468.       lut[i] = i ^ 255
  469.     end
  470.     #:::::
  471.     buffer = Bitmap.new(width, height)
  472.     for x in 0..width
  473.       for y in 0..height
  474.         px = get_pixel(x, y)
  475.         pixel = Color.new(lut[px.red], lut[px.green], lut[px.blue], px.alpha)
  476.         buffer.set_pixel(x, y, pixel)
  477.       end
  478.     end
  479.     return buffer
  480.   end
  481.   #-------------
  482.   #>>>>>>>>>>>>>>>>>>>
  483.   # Kehrt alle Farbwerte um.
  484.   #<<<<<<<<<<<<<<<<<<<
  485.   def negative!
  486.     buffer = negative
  487.     clear
  488.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  489.   end
  490.   #-------------
  491.   #>>>>>>>>>>>>>>>>>>>>
  492.   # Gibt das Graustufenbild der Bitmap zurĂźck, d.h. die Farbe jedes
  493.   # Pixels wird auf den Mittelwert seiner RGB-Werte gesetzt.
  494.   #<<<<<<<<<<<<<<<<<<<<
  495.   def grayscale
  496.     buffer = Bitmap.new(width, height)
  497.     for x in 0..width
  498.       for y in 0..height
  499.         color = get_pixel(x, y).grayscale
  500.         buffer.set_pixel(x, y, color)
  501.       end
  502.     end
  503.     return buffer
  504.   end
  505.   #-------------
  506.   #>>>>>>>>>>>>>>>>>>>
  507.   # Konvertiert die Bitmap zum Graustufenbild.
  508.   #<<<<<<<<<<<<<<<<<<<
  509.   def grayscale!
  510.     buffer = grayscale
  511.     clear
  512.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  513.   end
  514.   #-------------
  515.   #>>>>>>>>>>>>>>>>>>>
  516.   # Gibt die Bitmap verpixelt zurĂźck, d.h. Quadrate von factor * factor
  517.   # pixels werden zu ihrem Durchschnitt zusammengefasst.
  518.   #<<<<<<<<<<<<<<<<<<<
  519.   def pixelize(factor=2)
  520.     return dup if factor <= 1
  521.     #return scale(1.to_f/factor).scale(factor)
  522.     buffer = Bitmap.new(width, height)
  523.     for ix in 0..width/factor
  524.       for iy in 0..height/factor
  525.         x = ix*factor
  526.         y = iy*factor
  527.         color = average_color(x, y, factor, factor)
  528.         buffer.fill_rect(x, y, factor, factor, color)
  529.       end
  530.     end
  531.     return buffer
  532.   end
  533.   #-------------
  534.   #>>>>>>>>>>>>>>>>>>>
  535.   # Verpixelt die Bitmap.
  536.   #<<<<<<<<<<<<<<<<<<<
  537.   def pixelize!(factor=2)
  538.     buffer = pixelize(factor)
  539.     clear
  540.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  541.   end
  542.   #-------------
  543.   #>>>>>>>>>>>>>>>>>>>
  544.   # Gibt die Bitmap verwaschen zurĂźck. Der Algorithmus ist nicht sehr
  545.   # effezient. Wäre gut, wenn jemand noch einen besseren fände.
  546.   #<<<<<<<<<<<<<<<<<<<
  547.   def blur(f=1)
  548.     buffer = Bitmap.new(width, height)
  549.     for x in 0..width
  550.       for y in 0..height
  551.         color = average_color(x-f, y-f, 2*f, 2*f)
  552.         buffer.set_pixel(x, y, color)
  553.       end
  554.     end
  555.     return buffer
  556.   end
  557.   #-------------
  558.   #>>>>>>>>>>>>>>>>>>>
  559.   # Verwäscht die Bitmap.
  560.   #<<<<<<<<<<<<<<<<<<<
  561.   def blur!(f=1)
  562.     buffer = blur(f)
  563.     clear
  564.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  565.   end
  566.   #-------------
  567.   #>>>>>>>>>>>>>>>>>>>
  568.   # Gibt die Bitmap "geschĂźttelt", d.h. mehrmals Ăźbereinander
  569.   # mit verringer Opacity gezeichnet, zurĂźck.
  570.   #<<<<<<<<<<<<<<<<<<<
  571.   def shake(d=1, horizontal=true, vertical=true)
  572.     return dup if d <= 0 or (! horizontal and ! vertical)
  573.     buffer = Bitmap.new(width, height)
  574.     if horizontal and vertical
  575.       buffer.blt(-d, -d, self, Rect.new(0, 0, width, height), 64)
  576.       buffer.blt(d, -d, self, Rect.new(0, 0, width, height), 64)
  577.       buffer.blt(-d, d, self, Rect.new(0, 0, width, height), 64)
  578.       buffer.blt(d, d, self, Rect.new(0, 0, width, height), 64)
  579.     elsif horizontal
  580.       buffer.blt(-d, 0, self, Rect.new(0, 0, width, height), 128)
  581.       buffer.blt(d, 0, self, Rect.new(0, 0, width, height), 128)
  582.     elsif vertical
  583.       buffer.blt(0, -d, self, Rect.new(0, 0, width, height), 128)
  584.       buffer.blt(0, d, self, Rect.new(0, 0, width, height), 128)
  585.     end
  586.     return buffer
  587.   end
  588.   #-------------
  589.   #>>>>>>>>>>>>>>>>>>>
  590.   # "SchĂźttelt" die Bitmap.
  591.   #<<<<<<<<<<<<<<<<<<<
  592.   def shake!(d=1, horizontal=true, vertical=true)
  593.     buffer = shake(d, horizontal, vertical)
  594.     clear
  595.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  596.   end
  597.   #-------------
  598.   #>>>>>>>>>>>>>>>>>>>
  599.   # Ă?ndert die Helligkeit der Bitmap.
  600.   # -- b: die Helligkeit, muss zwischen -255 (ganz schwarz)
  601.   #     und +255 (ganz weiĂ?) liegen.
  602.   #<<<<<<<<<<<<<<<<<<<
  603.   def change_brightness(b)
  604.     b = [[-255, b].max, 255].min
  605.     # Look Up Table
  606.     lut = Array.new(256)
  607.     for i in 0..255
  608.       if b >= 0
  609.         c = (255 - i) * (b.to_f/255) + i
  610.       else
  611.         c = i * ((255+b.to_f) / 255)
  612.       end
  613.       lut[i] = c
  614.     end
  615.     #::::::::::
  616.     for x in 0..width
  617.       for y in 0..height
  618.         px = get_pixel(x, y)
  619.         color = Color.new(lut[px.red], lut[px.green], lut[px.blue], px.alpha)
  620.         set_pixel(x, y, color)
  621.       end
  622.     end
  623.   end
  624.   #-------------
  625.   #>>>>>>>>>>>>>>>>>>>
  626.   # Verändert den Kontrast.
  627.   # -- contrast: der Parameter muss zwischen -127 und +127 liegen
  628.   #<<<<<<<<<<<<<<<<<<<
  629.   def change_contrast(contrast)
  630.     # LUT
  631.     lut = Array.new(256)
  632.     for i in 0..255
  633.       c = (i - 127 )*((contrast+127).to_f / 127) + 127
  634.       c = [[0, c].max, 255].min
  635.       lut[i] = c
  636.     end
  637.     #::::
  638.     for x in 0..width-1
  639.       for y in 0..height-1
  640.         px = get_pixel(x, y)
  641.         color = Color.new(lut[px.red], lut[px.green], lut[px.blue], px.alpha)
  642.         set_pixel(x, y, color)
  643.       end
  644.     end
  645.   end
  646.   #-------------
  647.   #>>>>>>>>>>>>>>>>>>>
  648.   # Mit dem Threshold-Algorithmus wird ein Schwarz-WeiĂ?-Bild erzeugt.
  649.   # -- s (128): fĂźr jedes Pixel wird der Mittelwert der RGB-Werte gebildet, liegt
  650.   #     er unterhalb des Grenzwertes s, wird das Pixel schwarz, ansonsten weiĂ?.
  651.   #<<<<<<<<<<<<<<<<<<<
  652.   def threshold(s=128)
  653.     buffer = Bitmap.new(width, height)
  654.     for x in 0..width-1
  655.       for y in 0..height-1
  656.         px = get_pixel(x, y)
  657.         b = px.red + px.green + px.blue
  658.         color = b < 3*s ? Color.black(px.alpha) : Color.white(px.alpha)
  659.         buffer.set_pixel(x, y, color)
  660.       end
  661.     end
  662.     return buffer
  663.   end
  664.   #-------------
  665.   #>>>>>>>>>>>>>>>>>>>
  666.   # Konvertiert die Bitmap nach Schwarz-WeiĂ? mit dem Threshold-Algorithmus.
  667.   # -- s (128): fĂźr jedes Pixel wird der Mittelwert der RGB-Werte gebildet, liegt
  668.   #     er unterhalb des Grenzwertes s, wird das Pixel schwarz, ansonsten weiĂ?.
  669.   #<<<<<<<<<<<<<<<<<<<
  670.   def threshold!(s=128)
  671.     buffer = threshold(s)
  672.     clear
  673.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  674.   end
  675.   #-------------
  676.   # Gibt die Bitmap "geprägt", als Relief, zurĂźck.
  677.   #<<<<<<<<<<<<<<<<<<<
  678.   def emboss
  679.     buffer = Bitmap.new(width, height)
  680.     for x in 0..width-1
  681.       for y in 0..height-1
  682.         px = get_pixel(x, y)
  683.         c = (px.average - get_pixel(x+1, y+1).average) + 128
  684.         color = Color.new(c, c, c, px.alpha)
  685.         buffer.set_pixel(x, y, color)
  686.       end
  687.     end
  688.     return buffer
  689.   end
  690.   #-------------
  691.   #>>>>>>>>>>>>>>>>>>>
  692.   # "Prägt" die Bitmap, eine Art Relief wird erzeugt.
  693.   #<<<<<<<<<<<<<<<<<<<
  694.   def emboss!
  695.     buffer = emboss
  696.     clear
  697.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  698.   end
  699.   #-------------
  700.   #>>>>>>>>>>>>>>>>>>>
  701.   # Gibt die Bitmap mit einem bestimmten Faktor verkleinert / gestreckt zurĂźck.
  702.   # -- factor_x: Faktor fĂźr horizontale Streckung
  703.   # -- factor_y (factor_x): Faktor fĂźr vertikale Streckung
  704.   #<<<<<<<<<<<<<<<<<<<
  705.   def scale(factor_x, factor_y=factor_x)
  706.     buffer = Bitmap.new(width*factor_x, height*factor_y)
  707.     buffer.stretch_blt(buffer.rect, self, rect)
  708.     return buffer
  709.   end
  710.   #-------------
  711.   #>>>>>>>>>>>>>>>>>>>
  712.   # Gibt die Bitmap auf eine bestimmte GrĂśĂ?e gestreckt / verkleinert zurĂźck.
  713.   # -- width: Breite
  714.   # -- height: HĂśhe
  715.   #<<<<<<<<<<<<<<<<<<<
  716.   def scale_to(width, height)
  717.     factor_x = width.to_f / self.width
  718.     factor_y = height.to_f / self.height
  719.     return scale(factor_x, factor_y)
  720.   end
  721.   #-------------
  722.   #>>>>>>>>>>>>>>>>>>>
  723.   # Gibt einen Teil der Bitmap auf die volle GrĂśĂ?e gestreckt zurĂźck.
  724.   # -- x, y, width, height: Ausschnitt der Bitmap
  725.   #<<<<<<<<<<<<<<<<<<<
  726.   def zoom_area(x, y, width, height)
  727.     return area(x, y, width, height).scale_to(self.width, self.height)
  728.   end
  729.   #-------------
  730.   #>>>>>>>>>>>>>>>>>>>
  731.   # Ă?ndert die Bitmap zu einem Ausschnitt, der auf die volle GrĂśĂ?e
  732.   # gestreckt wird.
  733.   # -- x, y, width, height: Ausschnitt der Bitmap
  734.   #<<<<<<<<<<<<<<<<<<<
  735.   def zoom_area!(x, y, width, height)
  736.     buffer = zoom_area(x, y, width, height)
  737.     clear
  738.     blt(0, 0, buffer, Rect.new(0, 0, self.width, self.height))
  739.   end
  740.   #-------------
  741.   #>>>>>>>>>>>>>>>>>>>
  742.   # Ă?ndert die Opacity der Bitmap.
  743.   # -- opacity: Wert zwischen 0 und 255
  744.   #<<<<<<<<<<<<<<<<<<<
  745.   def change_opacity(opacity)
  746.     buffer = Bitmap.new(width, height)
  747.     buffer.blt(0, 0, self, Rect.new(0, 0, width, height), opacity)
  748.     clear
  749.     blt(0, 0, buffer, Rect.new(0, 0, self.width, self.height))
  750.   end
  751.   #-------------
  752.   #>>>>>>>>>>>>>>>>>>>
  753.   # Zeichnet ein mit einem FarbĂźbergang gefĂźlltes Rechteck.
  754.   # -- x, y, width, height: Rechteck
  755.   # -- color1: erste Farbe (links)
  756.   # -- color2: zweite Farbe (rechts)
  757.   #<<<<<<<<<<<<<<<<<<<
  758.   def fill_rect_horizontal_gradient(x, y, width, height, color1, color2)
  759.     r1 = color1.red
  760.     g1 = color1.green
  761.     b1 = color1.blue
  762.     a1 = color1.alpha
  763.     r2 = color2.red
  764.     g2 = color2.green
  765.     b2 = color2.blue
  766.     a2 = color2.alpha
  767.     for i in x..(x+width)
  768.       k = i / (x+width).to_f
  769.       red = k*(r2-r1)+r1
  770.       green = k*(g2-g1)+g1
  771.       blue = k*(b2-b1)+b1
  772.       alpha = k*(a2-a1)+a1
  773.       color = Color.new(red, green, blue, alpha)
  774.       fill_rect(i, y, 1, height, color)
  775.     end
  776.   end
  777.   #---------------
  778.   #>>>>>>>>>>>>>>>>>>>
  779.   # FĂźllt ein Rechteck, gefĂźllt mit einem vertikalen FarbĂźbergang von
  780.   # color1 zu color2.
  781.   # -- x, y, width, height: Rechteck
  782.   # -- color1: erste Farbe (oben)
  783.   # -- color2: zweite Farbe (unten)
  784.   #<<<<<<<<<<<<<<<<<<<
  785.   def fill_rect_vertical_gradient(x, y, width, height, color1, color2)
  786.     r1 = color1.red
  787.     g1 = color1.green
  788.     b1 = color1.blue
  789.     a1 = color1.alpha
  790.     r2 = color2.red
  791.     g2 = color2.green
  792.     b2 = color2.blue
  793.     a2 = color2.alpha
  794.     for i in y..height
  795.       k = i / (y+height).to_f
  796.       red = k*(r2-r1)+r1
  797.       green = k*(g2-g1)+g1
  798.       blue = k*(b2-b1)+b1
  799.       alpha = k*(a2-a1)+a1
  800.       color = Color.new(red, green, blue, alpha)
  801.       fill_rect(x, i, width, 1, color)
  802.     end
  803.   end
  804.   #-----------------
  805.   #>>>>>>>>>>>>>>>>>
  806.   # Gibt die Bitmap mit vertauschten RGB-Farbwerten zurĂźck.
  807.   # -- order: die neue Reihenfolge der Farbwerte, muss einer von
  808.   #     folgenden Strings sein: "rgb", "bgr", "brg", "grb", "gbr"
  809.   #<<<<<<<<<<<<<<<<<
  810.   def swap_colors(order)
  811.     buffer = Bitmap.new(width, height)
  812.     for x in 0..width
  813.       for y in 0..height
  814.         color = get_pixel(x, y).swap(order)
  815.         buffer.set_pixel(x, y, color)
  816.       end
  817.     end
  818.     return buffer
  819.   end
  820.   #-----------------
  821.   #>>>>>>>>>>>>>>>>>
  822.   # Vertauscht die RGB-Farbwerte der Bitmap.
  823.   # -- order: die neue Reihenfolge der Farbwerte, muss einer von
  824.   #     folgenden Strings sein: "rgb", "bgr", "brg", "grb", "gbr"
  825.   #<<<<<<<<<<<<<<<<<
  826.   def swap_colors!(order)
  827.     for x in 0..width
  828.       for y in 0..height
  829.         color = get_pixel(x, y).swap(order)
  830.         set_pixel(x, y, color)
  831.       end
  832.     end
  833.   end
  834.   #-----------------
  835.   #>>>>>>>>>>>>>>>>>
  836.   # Gibt die Bitmap mit ersetzten Farben zurĂźck.
  837.   # -- red, green, blue, alpha: zu ersetzende Farbe, die Parameter kĂśnnen sein:
  838.   #     - ein genauer Wert, z.B. 172
  839.   #     - ein Wertebereich, z.B. 100..200
  840.   #     - -1 (Farbwert ist egal)
  841.   # -- red2, green2, blue2, alpha2: neue Farbe, die Parameter kĂśnnen sein:
  842.   #     - ein genauer Wert, z.B. 215
  843.   #     - -1 (Farbwert wird nicht geändert)
  844.   #<<<<<<<<<<<<<<<<<
  845.   def replace_colors(red, green, blue, alpha, red2, green2, blue2, alpha2)
  846.     buffer = Bitmap.new(width, height)
  847.     for x in 0..width
  848.       for y in 0..height
  849.         color = get_pixel(x, y)
  850.         if ((red.is_a?(Range) and red.include?(color.red)) or
  851.               color.red == red or
  852.                red == -1) and
  853.             ((green.is_a?(Range) and green.include?(color.green)) or
  854.               color.green == green or
  855.               green == -1) and
  856.             ((blue.is_a?(Range) and blue.include?(color.blue)) or
  857.               color.blue == blue or
  858.               blue == -1)  and
  859.             ((alpha.is_a?(Range) and alpha.include?(color.alpha)) or
  860.               color.alpha == alpha or
  861.               alpha == -1)
  862.           new_red = red2 == -1 ? color.red : red2
  863.           new_green = green2 == -1 ? color.green : green2
  864.           new_blue = blue2 == -1 ? color.blue : blue2
  865.           new_alpha = alpha2 == -1 ? color.alpha : alpha2
  866.           new_color = Color.new(new_red, new_green, new_blue, new_alpha)
  867.         else
  868.           new_color = get_pixel(x, y)
  869.         end
  870.         buffer.set_pixel(x, y, new_color)
  871.       end
  872.     end
  873.     return buffer
  874.   end
  875.   #-----------------
  876.   #>>>>>>>>>>>>>>>>>
  877.   # Ersetzt Farben.
  878.   # -- red, green, blue, alpha: zu ersetzende Farbe, die Parameter kĂśnnen sein:
  879.   #     - ein genauer Wert, z.B. 172
  880.   #     - ein Wertebereich, z.B. 100..200
  881.   #     - -1 (Farbwert ist egal)
  882.   # -- red2, green2, blue2, alpha2: neue Farbe, die Parameter kĂśnnen sein:
  883.   #     - ein genauer Wert, z.B. 215
  884.   #     - -1 (Farbwert wird nicht geändert)
  885.   #<<<<<<<<<<<<<<<<<
  886.   def replace_colors!(red, green, blue, alpha, red2, green2, blue2, alpha2)
  887.     buffer = replace_colors(red, green, blue, alpha, red2, green2, blue2, alpha2)
  888.     clear
  889.     blt(0, 0, buffer, Rect.new(0, 0, width, height))
  890.   end
  891.   #-----------------
  892.   #>>>>>>>>>>>>>>>>>
  893.   # Gibt einen Ausschnitt der Bitmap zurĂźck.
  894.   # -- x, y, width, height: Ausschnitt
  895.   #<<<<<<<<<<<<<<<<<
  896.   def area(x, y, width, height)
  897.     buffer = Bitmap.new(width, height)
  898.     src_rect = Rect.new(x, y, width, height)
  899.     buffer.blt(0, 0, self, src_rect)
  900.     return buffer
  901.   end
  902.   #-----------------
  903.   #>>>>>>>>>>>>>>>>>
  904.   # Gibt die durchschnittliche Farbe in einem Ausschnitt der Bitmap zurĂźck.
  905.   # -- x, y, width, height: Ausschnitt
  906.   # Die Methode ist ein wenig unperformant, sollte also nicht zu oft
  907.   # hintereinander aufgerufen werden.
  908.   #<<<<<<<<<<<<<<<<<
  909.   def average_color(x, y, width, height)
  910.     width = [self.width, x+width].min
  911.     height = [self.height, y+height].min
  912.     red = green = blue = alpha = 0
  913.     count = 0
  914.     for ix in x..width
  915.       for iy in y..height
  916.         px = get_pixel(ix, iy)
  917.         red += px.red
  918.         green += px.green
  919.         blue += px.blue
  920.         alpha += px.alpha
  921.         count += 1
  922.       end
  923.     end
  924.     red /= count
  925.     green /= count
  926.     blue /= count
  927.     alpha /= count
  928.     return Color.new(red, green, blue, alpha)
  929.   end
  930. end
  931. #====
  932. class Color
  933.   #>>>>>>>>>>>>>>>>>>>>>
  934.   # Gibt die Farbe als Integer zurĂźck. Das erste Byte steht fĂźr den
  935.   # Alpha-Wert, das zweite fĂźr den Rot-Wert etc.
  936.   #<<<<<<<<<<<<<<<<<<<<<
  937.   def int
  938.     return ((alpha.to_i & 0xFF) << 24) |
  939.               ((red.to_i & 0xFF) << 16) |
  940.               ((green.to_i & 0xFF) << 8) |
  941.               ((blue.to_i & 0xFF) << 0)
  942.   end
  943.   #----------
  944.   #>>>>>>>>>>>>>>>>>>>>>
  945.   # Gibt eine etwas hellere Farbe zurĂźck.
  946.   # -- factor: der Faktor, mit dem die Farbe errechnet wird, muss
  947.   #     zwischen 0.0 und 1.0 liegen
  948.   # Die Methoden brighter und darker sind nicht umkehrbar!
  949.   #<<<<<<<<<<<<<<<<<<<<<
  950.   def brighter(factor=0.7)
  951.     factor = 1-[[0, factor].max, 1].min
  952.     new_red = factor*(255-red) + red
  953.     new_green = factor*(255-green) + green
  954.     new_blue = factor*(255-blue) + blue
  955.     return Color.new(new_red, new_green, new_blue, alpha)
  956.   end
  957.   #--------
  958.   #>>>>>>>>>>>>>>>>>>>>>
  959.   # Gibt eine etwas dunklere Farbe zurĂźck.
  960.   # -- factor: der Faktor, mit dem die Farbe errechnet wird, muss
  961.   #     zwischen 0.0 und 1.0 liegen
  962.   # Die Methoden brighter und darker sind nicht umkehrbar!
  963.   #<<<<<<<<<<<<<<<<<<<<<
  964.   def darker(factor=0.7)
  965.     factor = [[0, factor].max, 1].min
  966.     new_red = red * factor
  967.     new_green = green * factor
  968.     new_blue = blue * factor
  969.     return Color.new(new_red, new_green, new_blue, alpha)
  970.   end
  971.   #-----------
  972.   #>>>>>>>>>>>>>>>>>>>
  973.   # Gibt die Komplementärfarbe zurĂźck, d.h. die RGB-Werte werden
  974.   # umgekehrt.
  975.   #<<<<<<<<<<<<<<<<<<<
  976.   def negative
  977.     #return Color.new(255-red, 255-green, 255-blue, alpha)
  978.     #return int ^ 0xFFFFFF
  979.     return Color.new(red ^ 0xFF, green ^ 0xFF, blue ^ 0xFF, alpha)
  980.   end
  981.   #-----------
  982.   #>>>>>>>>>>>>>>>>>>>
  983.   # Gibt die Farbe als Graustufe zurĂźck, d.h. die RGB-Werte sind gleich.
  984.   #<<<<<<<<<<<<<<<<<<<
  985.   def grayscale
  986.     g = average
  987.     return Color.new(g, g, g, alpha)
  988.   end
  989.   #-----------
  990.   #>>>>>>>>>>>>>>>>>>>
  991.   # Gibt den Durchschnitt der RGB-Werte zurĂźck.
  992.   #<<<<<<<<<<<<<<<<<<<
  993.   def average
  994.     return Math.average(red, green, blue)
  995.   end
  996.   #-----------
  997.   #>>>>>>>>>>>>>>>>>>>
  998.   # Gibt die Farbe mit vertauschten Werten zurĂźck.
  999.   # -- order: die neue Reihenfolge der Farbwerte, muss einer von
  1000.   #     folgenden Strings sein: "rgb", "bgr", "brg", "grb", "gbr"
  1001.   #<<<<<<<<<<<<<<<<<<<
  1002.   def swap(order)
  1003.     order.downcase!
  1004.     o = ["rbg", "bgr", "brg", "grb", "gbr"]
  1005.     return self if not o.include?(order)
  1006.     case o.index(order)
  1007.     when 0
  1008.       return Color.new(red, blue, green, alpha)
  1009.     when 1
  1010.       return Color.new(blue, green, red, alpha)
  1011.     when 2
  1012.       return Color.new(blue, red, green, alpha)
  1013.     when 3
  1014.       return Color.new(green, red, blue, alpha)
  1015.     when 4
  1016.       return Color.new(green, blue, red, alpha)
  1017.     end
  1018.   end
  1019.   #-----------
  1020.   #>>>>>>>>>>>>>>>>>>>
  1021.   # Gibt die Farbe in der Hexadezimalschreibweise (als String) zurĂźck.
  1022.   #<<<<<<<<<<<<<<<<<<<
  1023.   def encode
  1024.     format = "%02x"
  1025.     return (format % red) + (format % green) + (format % blue) + (format % alpha)
  1026.   end
  1027.   #-----------
  1028.   #>>>>>>>>>>>>>>>>>>>
  1029.   # Wertet einen String in der Hexadezimalschreibweise (z.B. "0082d6")
  1030.   # aus und gibt die Farbe zurĂźck.
  1031.   #<<<<<<<<<<<<<<<<<<<
  1032.   def Color.decode(hex)
  1033.     hex.downcase!
  1034.     red = hex[0..1].hex
  1035.     green = hex[2..3].hex
  1036.     blue = hex[4..5].hex
  1037.     alpha = hex.length == 8 ? hex[6..7].hex : 255
  1038.     return Color.new(red, green, blue, alpha)
  1039.   end
  1040.   #-----------
  1041.   #>>>>>>>>>>>>>>>>>>>
  1042.   # einige Farbkonstanten, sehr nĂźtzlich:
  1043.   #<<<<<<<<<<<<<<<<<<<
  1044.   def Color.white(alpha=255)
  1045.     return Color.new(255, 255, 255, alpha)
  1046.   end
  1047.   #-----------
  1048.   def Color.black(alpha=255)
  1049.     return Color.new(0, 0, 0, alpha)
  1050.   end
  1051.   #----------
  1052.   def Color.red(alpha=255)
  1053.     return Color.new(255, 0, 0, alpha)
  1054.   end
  1055.   #----------
  1056.   def Color.green(alpha=255)
  1057.     return Color.new(0, 255, 0, alpha)
  1058.   end
  1059.   #---------
  1060.   def Color.blue(alpha=255)
  1061.     return Color.new(0, 0, 255, alpha)
  1062.   end
  1063.   #----------
  1064.   def Color.yellow(alpha=255)
  1065.     return Color.new(255, 255, 0, alpha)
  1066.   end
  1067.   #----------
  1068.   def Color.cyan(alpha=255)
  1069.     return Color.new(0, 255, 255, alpha)
  1070.   end
  1071.   #----------
  1072.   def Color.magenta(alpha=255)
  1073.     return Color.new(255, 255, 0, alpha)
  1074.   end
  1075.   #----------
  1076.   def Color.light_gray(alpha=255)
  1077.     return Color.new(192, 192, 192, alpha)
  1078.   end
  1079.   #-----------
  1080.   def Color.gray(alpha=255)
  1081.     return Color.new(128, 128, 128, alpha)
  1082.   end
  1083.   #-----------
  1084.   def Color.dark_gray(alpha=255)
  1085.     return Color.new(64, 64, 64, alpha)
  1086.   end
  1087.   #-----------
  1088.   def Color.pink(alpha=255)
  1089.     return Color.new(255, 175, 175, alpha)
  1090.   end
  1091.   #-----------
  1092.   def Color.orange(alpha=255)
  1093.     return Color.new(255, 200, 0, alpha)
  1094.   end
  1095. end
  1096. #==========
  1097. class Rect
  1098.   #>>>>>>>>>>>>>>>>>>>>>
  1099.   # Gibt true zurĂźck, wenn der Punkt (x, y) innerhalb des Rechteckes liegt.
  1100.   #<<<<<<<<<<<<<<<<<<<<<
  1101.   def inside?(x, y)
  1102.     return ((x >= self.x) and (x < self.x+width) and
  1103.         (y >= self.y) and (y < self.y+height))
  1104.   end
  1105. end
  1106. #==========
  1107. class Window_Base
  1108.   #>>>>>>>>>>>>>>>>>>>>>
  1109.   # Zeichnet die Battlergrafik.
  1110.   # -- actor: der Held, dessen Grafik gezeichnet werden soll
  1111.   #<<<<<<<<<<<<<<<<<<<<<
  1112.   def draw_actor_battler(actor, x, y)
  1113.     bitmap = RPG::Cache.battler(actor.battler_name, actor.battler_hue)
  1114.     self.contents.blt(x, y, bitmap, Rect.new(0, 0, bitmap.width, bitmap.height))
  1115.   end
  1116. end
  1117. #==========
  1118. module Math
  1119.   #>>>>>>>>>>>>>>>>>>>>>
  1120.   # Gibt den Absolutwert (Betrag) einer Zahl zurĂźck.
  1121.   #<<<<<<<<<<<<<<<<<<<<<
  1122.   def self.abs(num)
  1123.     return num<0 ? -num : num
  1124.   end
  1125.   #----------
  1126.   #>>>>>>>>>>>>>>>>>>>>>
  1127.   # Errechnet den Durchschnitt der Ăźbergebenen Zahlen.
  1128.   #<<<<<<<<<<<<<<<<<<<<<
  1129.   def self.average(*nums)
  1130.     sum = 0
  1131.     for i in nums
  1132.       sum += i
  1133.     end
  1134.     return sum.to_f / nums.size
  1135.   end
  1136. end
  1137. #//////////////////////////////////////////////////////////
  1138. # Verbesserungsvorschläge, Bugreports etc. an [email protected]
  1139. #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!