Table des pixels d'une image

[Guimauve]

Bonjour à tous,

Est-ce qu'il y a un moyen plus rapide d'obtenir la table de pixel que celle du code ci-dessous :

Code : Tout sélectionner

Procedure LoadOpenGLTexture(FileName.s, TransparentColor.l = -1) 
  
  img.l = LoadImage(#PB_Any, FileName) 
  width.l = ImageWidth(img) 
  height.l = ImageHeight(img) 
  Dim ImageData.b(width * height * 4) 

  StartDrawing(ImageOutput(img)) 
    
    For x = 0 To height - 1

      For y = 0 To width - 1 
        
        Color = Point(x,y) 
        
        ImageData(i) = Red(Color) 
        i+1 
        ImageData(i) = Green(Color) 
        i+1 
        ImageData(i) = Blue(Color) 
        i+1 
        
        If Color = TransparentColor 
          ImageData(i) = 0 
        Else
          ImageData(i) = $FF
        EndIf 
        
        i+1 
        
      Next
      
    Next
    
  StopDrawing()
  
  glGenTextures_(1, @TextureID) 
  glBindTexture_(#GL_TEXTURE_2D, TextureID) 
  glTexParameteri_(#GL_TEXTURE_2D, #GL_TEXTURE_MAG_FILTER, #GL_NEAREST) 
  glTexParameteri_(#GL_TEXTURE_2D, #GL_TEXTURE_MIN_FILTER, #GL_NEAREST) 
  glTexImage2D_(#GL_TEXTURE_2D, 0, #GL_RGBA, width, height, 0, #GL_RGBA, #GL_UNSIGNED_BYTE, @ImageData()) 
  
  ProcedureReturn TextureID
EndProcedure

Il me semble que la méthode montré plus haut (L'utilisation du tableau ImageData), bien que fonctionnelle ne soit pas classé parmi les plus rapides. Peut-être que pour le chargement ça peut toujours aller mais pour une texture procédurale, on n'est pas sorti de l'auberge.

Quelqu'un à une idée ?

Merci à l'avance.
Guimauve

[case]

si tu es sous windows,cette procédure copie une image vers une zone mémoire ou il est possible de la lire octet par octet c'est pas de moi, j'ai trouvé ce code sur le forum anglais il me semble de trond a voir si c'est plus rapide que ta méthode... ca utilise les API malheureusement si tu es sous linux ou mac os.

Code : Tout sélectionner

declare getmem(id)
; ne pas oublier d'utiliser le decoder aproprié
;img=loadimage"#pb_any,"mon_image"

;buffer=getmem(img)


Procedure getmem(ID)
	ImageID=  ImageID(id)
	Hdc = CreateCompatibleDC_ ( GetDC_ ( ImageID ))
	If HDC
		bmi.BITMAPINFO
		bm.BITMAP
		GetObject_ ( ImageID , SizeOf(BITMAP), @bm.BITMAP)
		bmi\bmiHeader\biSize = SizeOf(BITMAPINFOHEADER)
		bmi\bmiheader\biWidth = bm\bmWidth
		bmi\bmiheader\biHeight = bm\bmHeight
		bmi\bmiheader\biPlanes = 1
		bmi\bmiheader\biBitCount = 32
		bmi\bmiheader\biCompression = #BI_RGB
		HList = AllocateMemory (bm\bmWidth*bm\bmHeight*4)
		GetDIBits_ (hDC, ImageID ,0,bm\bmHeight,HList,bmi, #DIB_RGB_COLORS ) 	
		ProcedureReturn HList
	EndIf
EndProcedure

[Fred]

A partir de la 4.40, tu peux utiliser DrawingBuffer() qui renvoie directement la zone mémoire des pixels, que tu peux lire directement, ca devrait etre plus rapide. Pour ce que tu veux faire, tu devrais meme pouvoir passer le pointeur directement

[Guimauve]

J'ai oublié hier, le code plus haut date du mois d'octobre 2008 déjà et il est de CPL Bator si je ne me trompe pas.

@ Case

Je suis désolé mais ton code fonctionne que sous Windows, l'ennui c'est que moi et Windows ça ne fait plus très bon ménage depuis plusieurs années mais les choses se sont dégradés avec l'arrivée de Windows 7 tellement que je tourne sur Ubuntu 9.10 à 100% depuis 3 mois environ.

A partir de la 4.40, tu peux utiliser DrawingBuffer() qui renvoie directement la zone mémoire des pixels, que tu peux lire directement, ca devrait être plus rapide. Pour ce que tu veux faire, tu devrais même pouvoir passer le pointeur directement

Super, je vais regarder ça. Mais puisque la table des pixels fait partie de l'image ne serait-il pas préférable d'avoir une fonction du genre directement dans la librairie Image ?

Dans le style :

Code : Tout sélectionner

Largeur = ImageWidth(#Image)
Hauteur = ImageHeight(#Image)
PixelsBuffer = ImagePixelsBuffer(#Image)

Quoiqu'il en soit merci Fred pour ton aide.

A+
Guimauve

[Fred]

Non, parce que sous certains OS, il faut 'locker' les pixels avant de les manipuler. StartDrawing() s'en charge.

[Guimauve]

Non, parce que sous certains OS, il faut 'locker' les pixels avant de les manipuler. StartDrawing() s'en charge.

Ce qui explique pourquoi on retrouve ses fonctions dans la librairie SDL.

Code : Tout sélectionner

SDL_LockSurface(*Surface.SDL_Surface)
SDL_UnlockSurface(*Surface.SDL_Surface)

Je ne comprenais pas trop le pourquoi de cette pratique...

Merci pour les explications, c'est toujours apprécié.

A+
Guimauve