darkleo.myopenid.com

[Ruby] On I'm having trouble thinking in Ruby today.

2010-05-24T10:39:35-07:00

Range#map ?

# Read data and convert it
file = File.open("18.txt", 'r')
data = []
file.each_line {|line| 
  data << line.split(/ /).map {|i| i.to_i}}
file.close

n = data.size
(1..n).map {|i|
  (2..data[n-i].size).map {|k|
    data[n-i-1][k-2] += data[n-i][k-2, 2].max}}

p data[0][0]

[Ruby] On Anagram Solver

2010-02-19T22:01:02-08:00

and what wrong with reverse ?
"stressed".reverse => "desserts"

[Ruby] On Symplify few loops

2010-02-07T21:44:49-08:00

@Ants : It is obviously much faster with powers of two, at least with ruby-opengl
@Ben Marini : Thank you very much, It will help me a lot, particularly the methods 'map' and 'flatten'

[Ruby] On Symplify few loops

2010-01-31T21:36:36-08:00

I read `data`, `width` and `height` directly from a bmp file.
To use it, OpenGL requires that the image size (on each dimension) be a power of 2.
So `real_size` is the closest power of 2 who match the image size.
The original data is encoded in BGR, and i need it in RGBA.
Finally i need to reverse the rows, because the data "begin from the end"

I give an example with a very simple bitmap, 3 rows, 2 columns :
Red/Red
Green/Green
Blue/Blue

With this 3*2 bitmap :
data = [ 255, 0, 0, # 1st pixel, blue (third row)
255, 0, 0, # 2st pixel, blue
0, 255, 0, # 3nd pixel, green (second row)
0, 255, 0, # 4nd pixel, green
0, 0, 255, # 5rd pixel, red (first row)
0, 0, 255, # 6rd pixel, red
]
width = 2
height = 3

We calculate :
real_size = 4 # closest power of 2

And we obtain a 4*4 bitmap :
corrected = [ 255, 0, 0, 255 # 1st pixel, red (first row)
255, 0, 0, 255 # 2st pixel, red
0, 0, 0, 0 # Empty
0, 0, 0, 0 # Empty
0, 255, 0, 255 # 3nd pixel, green (second row)
0, 255, 0, 255 # 4nd pixel, green
0, 0, 0, 0 # Empty
0, 0, 0, 0 # Empty
0, 0, 255, 255 # 5rd pixel, blue (third row)
0, 0, 255, 255 # 6rd pixel, blue
0, 0, 0, 0 # Empty
0, 0, 0, 0 # Empty
0, 0, 0, 0 # Empty (last row)
0, 0, 0, 0 # Empty
0, 0, 0, 0 # Empty
0, 0, 0, 0 # Empty
]

I give also the entire method.
Thanks a lot by advance !

  def self.load_bmp name
    fail unless FileTest.exist?('Media/'+name)
    file = File.open('Media/'+name, 'rb')
    struct = {:name => name}
    file.seek(18, IO::SEEK_CUR)
    # Read width and height
    struct[:width]      = file.read(4).unpack('i')[0]
    struct[:height]     = file.read(4).unpack('i')[0]
    # Calculate closest power of 2
    struct[:real_size]  = 2
    struct[:real_size] *= 2 while struct[:real_size] < struct[:width]
    struct[:real_size] *= 2 while struct[:real_size] < struct[:height]
    file.seek(28, IO::SEEK_CUR)
    # Read data from file
    size = struct[:width]*struct[:height]*3
    data = file.read(size).unpack('C*')
    file.close
    
    corrected = []
    # BGR => RGB & miror y
    for y in 0...(struct[:height])
      for x in 0...(struct[:width])
        z = (struct[:height]-y-1)*struct[:width]*3 + 3*x
        corrected << data[z+2]
        corrected << data[z+1]
        corrected << data[z  ]
        corrected << 255 # Add alpha value
      end
      for x in struct[:width]...struct[:real_size]
        corrected << 0
        corrected << 0
        corrected << 0
        corrected << 0
      end
    end
    for y in struct[:height]...struct[:real_size]
      for x in 0...struct[:real_size]
        corrected << 0
        corrected << 0
        corrected << 0
        corrected << 0
      end
    end
    # Return corrected texture
    struct[:data] = corrected.pack('C*')
    return struct
  end

[Ruby] Symplify few loops

2010-01-30T20:36:41-08:00

I need to reformat .bmp data, by adding a lot of '0'
But my code is... horribly ugly.
'data' contain the original data (array)
'corrected' is an empty array

Before process :
[XXXX
XXXX
XXXX]

After process :
[XXXX0000
XXXX0000
XXXX0000
00000000
00000000
00000000]

for y in 0...height
  for x in 0...width
    # BGR => RGB & miror y
    z = (height-y-1)*width*3 + 3*x
    corrected << data[z+2]
    corrected << data[z+1]
    corrected << data[z  ]
    corrected << 255 # Add alpha value
  end
  for x in width...real_size
    corrected << 0
    corrected << 0
    corrected << 0
    corrected << 0
  end
end
for y in height...real_size
  for x in 0...real_size
    corrected << 0
    corrected << 0
    corrected << 0
    corrected << 0
  end
end