PureBoard

Verfasst: **23.05.2006 11:02**

Hallo,

ich habe eine Matrix von 16x16 Werten.

Diese Werte sollen grafisch dargestellt werden, also jedem Wert wird eine Farbe zugeordnet.

Um ein geglättetes Bild zu bekommen werden Zwischenwerte berechnet.
Dabei wird immer das arithmetische Mittel der beiden benachbarten Werte gebildet. Zunächst auf der x-Achse, dann auf der y-Achse.

aus 16x16 wird schrittweise 31x31, dann 61x61, dann 121x121.

Hier der Code, wie derzeit 31x31 berechnet wird.

Code: Alles auswählen

Procedure feld_interpolieren31x31()
  
  x=0
  m=0
  max=15

  
    For x = 0 To max
      For y = 0 To max 
        feld_interpolierty1(x,m)=feldnormiert(x,y)
        m=m+1
        feld_interpolierty1(x,m)=(feldnormiert(x,y)+feldnormiert(x,y+1))/2
        m=m+1
      Next   
      feld_interpolierty1(x,m)=feldnormiert(x,max)
      m=0
    Next
    
    m=0
    For y = 0 To 30 
      For x = 0 To max
        feld_interpoliert1(m,y)=feld_interpolierty1(x,y)
        m=m+1
        feld_interpoliert1(m,y)=(feld_interpolierty1(x,y)+feld_interpolierty1(x+1,y))/2
        m=m+1
      Next   
      feld_interpoliert1(m,y)=feld_interpolierty1(x,31)
      m=0
    Next 
EndProcedure

Da ich pro Sekunde dereit mehr als 10 Matrizen bekomme, habe ich eine recht hohe CPU-Auslastung.

Nun zu meiner Frage: Kann man den Code oben soweit optimieren, daß das ganze deutlich schneller geht.
Ziel wäre es 25 Matrizen pro Sekunde zu verarbeiten.

Vielen Dank

Verfasst: **23.05.2006 11:10**

Warum berechnest du nicht sofort die 121x121-Matrix ohne die Zwischenstufen ?

Verfasst: **23.05.2006 12:37**

Hi r7mk4, ....

ich hab's mir jetzt nicht genau angeschaut, da Dein Beispiel ja nicht selbstständig lauffähig ist.

Aber mal so generell zu Berechnungen:

- Eine Multiplikation mit 0.5 ist schneller als eine Division durch 2.
- Wenn die DIM-Felder Integer sind, dann nimm am besten >>1 statt der Divion durch 2.

Sind halt keine Verbesserung der eigentlichen Berechnungslogik - aber dürte zumindest die jetzige Berechnung etwas beschleunigen.

Gruß, PureLust.

Verfasst: **23.05.2006 17:10**

> aus 16x16 wird schrittweise 31x31, dann 61x61, dann 121x121.
> Hier der Code, wie derzeit 31x31 berechnet wird.

> Procedure feld_interpolieren31x31()

das macht auf mich den eindruck, als ob du für jede interpolationsstufe eine eigene proc hast, das ist etwas umständlich. alleine die vielen sub-calls fressen einiges an zeit.

normalerweise würde man sowas eher rekursiv lösen...

übertrag mal die werte aus dem 16x16-array in ein 121x121-array (mit abstand, also Step

, und verkleinere die schrittweite bei fortschreitender berechnugstiefe...

PureBoard

Schneller Rechnen im Arbeitsspeicher - Matrix interpolieren

Schneller Rechnen im Arbeitsspeicher - Matrix interpolieren