Averaging / ''Smoothing'' a 2 dimensional array?/Forum (SoCoder)

Forum Home

Blitz
Averaging / ''Smoothing'' a 2 dimensional array?

User
Message
Posted : Wednesday, 23 November 2011, 01:10 | Permalink | Mark Here
Mog
Hey guys, Brains really off and i can't remember for the life of me how to smooth out the data in an array by averaging it all together, any tips / pointers? ----- I am Busy Mongoose - My Website Dev PC: AMD 8150-FX, 16gb Ram, GeForce GTX 680 2gb Current Project: Pyroxene
Posted : Wednesday, 23 November 2011, 01:15 | Permalink | Mark Here
Jayenkai
WW Entries : 103
avg=0 for x=1 to items avg=avg+item[x] next avg=avg/items --> Bulk simple average for all.. smooth=3 for x=1 to items-smooth avg=0 for sm=1 to smooth avg=avg+item[(x+sm)-1] next item[x]=avg/smooth next --> average clumps! -----
Posted : Wednesday, 23 November 2011, 01:41 | Permalink | Mark Here
spinal
I'd go with the 'clumps' idea, but only two values at a time. ----- 3DS - 1762-2660-3218
Posted : Saturday, 26 November 2011, 11:56 | Permalink | Mark Here
Teasy
; for 1 user

; setup (for demo)
Const screen_width  = 120;80
Const screen_height = 60
Graphics screen_width,screen_height , 0,3
SetBuffer BackBuffer()
SetFont LoadFont( "Small Fonts" , 10 )

; graph/posting type
Global test_graph_type = 2
; smoothing/algorithm type
Global smoothingtype = 1
; bar overlay
Global showbar = False

.restart

Const number_of_weeks = 7;12
Const days_per_week   =  7
Const number_of_days  = number_of_weeks * days_per_week 

Dim posts_per_day( number_of_days )

; test graph
SeedRnd MilliSecs()
Const test_max_posts_per_day = 20  ; average
Local num
Select test_graph_type
    ; smooth forum usage (from little to a lot)
    Case 1
        Color 64,96,128
        Text 0,0 , "1. Steady posting"
        For num = 1 To number_of_days
            ; sine (low first, high second) as base
            Local sinval# = (1-Sin(num*360/number_of_days))/2.
            ; with some random variation
            Local rndval# = sinval * Rnd(0.5,1.5)
            posts_per_day( num ) = test_max_posts_per_day * rndval
        Next
    ; erratic forum usage (sporadic peaks)
    Case 2
        Color 64,96,128
        Text 0,0 , "2. Erratic posting"
        Local value
        For num = 1 To number_of_days
            If Rand(1,100) <= 10
                value = Rand( 1,test_max_posts_per_day )
            Else
                value = 0
            End If
            posts_per_day( num ) = value
        Next
        ; have at least 1 point in the graph with max value
        posts_per_day( Rand(1,number_of_days) ) = test_max_posts_per_day
    ; linear graph from low to high
    Case 3
        Color 64,96,128
        Text 0,0 , "3. Linear graph L-R"
        For num = 1 To number_of_days
            posts_per_day( num ) = num*test_max_posts_per_day/number_of_days
        Next
    ; linear graph from high to low
    Case 4
        Color 64,96,128
        Text 0,0 , "4. Linear graph R-L"
        For num = 1 To number_of_days
            posts_per_day( number_of_days-num+1 ) = num*test_max_posts_per_day/number_of_days
        Next
    ; single (max) point in the center
    Case 5
        Text 0,0 , "5. One spamday"
        ;posts_per_day( number_of_days/2 ) = test_max_posts_per_day
        posts_per_day( Rand(1,number_of_days) ) = test_max_posts_per_day
End Select

; debugging graph (right side of screen)
;Local num
Local x,y
For num = 1 To number_of_days
    x = screen_width-1 - posts_per_day( num )
    y = num-1
    Color 128,96,64
    Rect x,y , posts_per_day( num ),1
    Color 255,192,128
    Plot x,y
Next

; scale the points up for major improve in accuracy/smoothing
Const points_scale_value# = 10
;Local num
DebugLog ""
DebugLog ""
For num = 1 To number_of_days
    DebugLog "num "+num+" val "+posts_per_day(num)+" scl "+posts_per_day(num)*points_scale_value
    posts_per_day( num ) = posts_per_day( num ) * points_scale_value
Next

; add smoothing (optional)
Select smoothingtype
    Case 0
        Color 64,96,128
        Text 0,10 , "0. No smoothing"
        Goto nosmooth
    Case 1  Goto smooth1  ; block smooth (advanced)
    Case 2  Goto smooth2  ; incremental smooth (lame)
    Case 3  Goto smooth3  ; curve smooth (lame)
    Case 4  Goto smooth4  ; reverse double smooth
    Case 5  Goto smooth5  ; dynamic interpolation (advanced)
End Select

; average block smoothing with interpolation
.smooth1
Color 64,96,128
Text 0,10 , "1. Block smoothing"
ApplyBlockSmooth
Const smoothingblocks = 7  ; divide graph in even segments
Function ApplyBlockSmooth()
    ; - calc average of segments
    Local averagepoints[ smoothingblocks ]  ; posts per day, average per segment
    Local count,total
    Local newsegment
    Local oldsegment
    Local num
    For num = 1 To number_of_days
        count = count + 1
        total = total + posts_per_day( num )
        ; find segment for this point/day
        newsegment = (num-1)*smoothingblocks/number_of_days
        ; new segment or last point/day
        If newsegment > oldsegment Or num = number_of_days
            ; calculate old average and store point
            If oldsegment > -1
                averagepoints[ oldsegment ] = total/count
            End If
            ; update segment and reset average
            oldsegment = newsegment
            count = 0
            total = 0
        End If
    Next
    ; - pad start/end of graph with first/last average
    Local smoothinginterval = number_of_days / smoothingblocks
    For num = 1 To smoothinginterval
        posts_per_day( num ) = averagepoints[ 0 ]
        posts_per_day( number_of_days-num+1 ) = averagepoints[ smoothingblocks-1 ]
    Next
    ; - apply interpolation to average points, and overwrite graph
    Local newvalue
    Local oldvalue
    Local segment
    ;Local oldsegment
    oldsegment = -1
    Local oldsegmentpoint
    Local newsegmentpoint
    Local segmentsize
    Local deltavalue#
    For num = 1 To number_of_days
        ; find segment for this point/day
        segment = (num-1)*smoothingblocks/number_of_days
        If segment > oldsegment
            oldsegment = segment
            oldsegmentpoint = num
            newsegmentpoint = (segment+1)*number_of_days/smoothingblocks
            segmentsize = newsegmentpoint-oldsegmentpoint
        End If
        ; find previous (current) and next average value
        oldvalue = averagepoints[ segment ]
        newvalue = averagepoints[ segment+1 ]
        ; calculate position (delta) in interpolated 'line'
        deltavalue = Float ( num - oldsegmentpoint ) / segmentsize
        ; shift by half a segment (center align)
        Local index = num+smoothinginterval/2
        posts_per_day( index ) = oldvalue + (newvalue-oldvalue) * deltavalue
        If posts_per_day( index ) < 0
            posts_per_day( index ) = 0
        End If
        ; average cuts off sides of graph
        If segment = smoothingblocks-1
            Exit
        End If
    Next
End Function
Goto nosmooth

; incremental average smoothing
.smooth2
Color 64,96,128
Text 0,10 , "2. Incremental smoothing"
Local total
total = 0
For num = 1 To number_of_days
    total = total + posts_per_day( num )
    ; smooth current value with total average (incremental)
    ;posts_per_day( num ) = ( posts_per_day( num ) + total/num ) / 2
    ;posts_per_day( num ) = total/num
    DebugLog "num "+num+" val "+posts_per_day(num)+" avg "+total/num+" tot "+total
Next
Goto nosmooth

; average smoothing with a curve
.smooth3
Color 64,96,128
Text 0,10 , "3. Curve smoothing"
;Local total
total = 0
Local prevvalue
For num = 1 To number_of_days
    If posts_per_day( num ) <= 0
        total = total / 1.11111
        If total < 0
            total = 0
        End If
    ElseIf posts_per_day( num ) >= prevvalue
        total = ( total + posts_per_day( num ) ) / 2
    ;Else
        ;total = posts_per_day( num )
    End If
    prevvalue = posts_per_day( num )
    ; smooth current value with total average (incremental)
    ;posts_per_day( num ) = ( posts_per_day( num ) + total/num ) / 2
    ;posts_per_day( num ) = total/num
    ;posts_per_day( num ) = ( posts_per_day( num ) + total ) / 2
    posts_per_day( num ) = total
Next
Goto nosmooth

; double (reverse) curve smoothing
.smooth4
Color 64,96,128
Text 0,10 , "4. Reverse smoothing"
; convert points to separate array
Local ArrayBank[ArrayBankLimit]
ClearArrayBank ArrayBank
;Local num
For num = 1 To number_of_days
    ArrayBank[num] = posts_per_day( num )
Next
; do the smooth
SmoothArrayBank ArrayBank , 1,number_of_days , 1.11111
; convert separate array back to points
For num = 1 To number_of_days
    posts_per_day( num ) = ArrayBank[num]
Next
Goto nosmooth

.smooth5
Color 64,96,128
Text 0,10 , "5. Dynamic smoothing"
; convert points to separate array
;Local ArrayBank[ArrayBankLimit]
ClearArrayBank ArrayBank
;Local num
For num = 1 To number_of_days
    ArrayBank[num] = posts_per_day( num )
Next
; do the smooth
DynamicSmoothArrayBank ArrayBank , 1,number_of_days
; convert separate array back to points
For num = 1 To number_of_days
    posts_per_day( num ) = ArrayBank[num]
Next
Goto nosmooth

.nosmooth

; find peak value
; - if all posts per day are 0
;   don't render/draw (and/or delete image)
Local peak = -1
;Local num
For num = 1 To number_of_days
    If posts_per_day( num ) > peak
        peak = posts_per_day( num )
    End If
Next
If peak = 0
    ;End
End If
;Text 0,screen_height-10 , "Peak: "+peak
;Local textstring$ = "Peak: "+peak
;Text screen_width-StringWidth(textstring),screen_height-FontHeight()*2 , textstring
Text 0,screen_height-FontHeight()*2 , "Peak: "+peak

; prepare render
Const image_width  = 48
Const image_height = 15

; prepare overlay (for gradient)
Local overlayimage = CreateImage( image_width,image_height )

; render graph
Local graphimage = CreateImage( image_width,image_height )
MaskImage graphimage , 255,0,255
SetBuffer ImageBuffer( graphimage )
;Local num
Local h
;Local x,y
Color 255,0,255
; - allow visual update even when all values are 0
If peak = 0 Then peak = 1
For num = 1 To number_of_days
    h = 1+(posts_per_day(num)+0)*image_height/peak
    x = (num-1)*image_width/number_of_days
    y = image_height-h
    Rect x,y , 1,h
Next

; render gradient overlay
Local gradientimage = LoadImage( "activitybar-gradient1a.png" )
SetBuffer ImageBuffer( overlayimage )
DrawBlock gradientimage , 0,0
DrawImage graphimage , 0,0

; show/demo with gradient
Local backimage = LoadImage( "activitybar1a.png" )
SetBuffer BackBuffer()
;Local x,y
x = screen_width/2-ImageWidth(backimage)/2
y = screen_height/2-ImageHeight(backimage)/2
Local xo = x + 8
Color 255,255,255
Rect xo,y , ImageWidth(overlayimage),ImageHeight(overlayimage) , False
Color 64,96,128
Text 0,GraphicsHeight()-FontHeight() , "Up Down Space Enter Esc"
DrawImage overlayimage , xo,y
If showbar
    DrawImage backimage , x,y
End If
Flip

FlushKeys
WaitKey
Cls
If Not KeyHit(1)
    If KeyHit(200)
        test_graph_type=test_graph_type+1
        If test_graph_type>5
            test_graph_type=1
        End If
    End If
    If KeyHit(208)
        smoothingtype=smoothingtype+1
        If smoothingtype>5
            smoothingtype=0
        End If
    End If
    If KeyHit(28)
        showbar=Not showbar
    End If
    Goto restart
End If
End

;-------------------------------------------------------------------------------
Const ArrayBankLimit = 1024

Function SmoothArrayBank( ArrayBank[ArrayBankLimit] , Offset,Size , divisor#=1 )
    Local times
    Local total
    Local num
    Local prevvalue
    Local endpoint = Offset+Size
    
    For times = 1 To 2
        ReverseArrayBank ArrayBank , Offset,Size
        total = 0
        prevvalue = 0
        For num = Offset To endpoint
            If ArrayBank[num] <= 0
                total = total / divisor
                If total < 0
                    total = 0
                End If
            ElseIf ArrayBank[num] >= prevvalue
                total = ( total + ArrayBank[num] ) / 2
            End If
            prevvalue = ArrayBank[num]
            ArrayBank[num] = total
        Next
    Next
End Function

Function ReverseArrayBank( ArrayBank[ArrayBankLimit] , Offset,Size )
    Local swap
    Local num
    Local reversenum
    Local endpoint = Offset+Size
    
    For num = Offset To endpoint
        reversenum = endpoint-(num-Offset)
        swap = ArrayBank[num]
        ArrayBank[num] = ArrayBank[reversenum]
        ArrayBank[reversenum] = swap
        ; only half of numbers needed
        If num >= Offset+Size/2
            Exit
        End If
    Next
End Function

Function ClearArrayBank( ArrayBank[ArrayBankLimit] , Offset=0,Size=ArrayBankLimit , ClearValue=0 )
    Local num
    Local endpoint = Offset+Size
    
    For num = Offset To endpoint
        ArrayBank[num] = ClearValue
    Next
End Function

Function FindNextNonZero( ArrayBank[ArrayBankLimit] , Offset )
    Local num
    
    For num = Offset To ArrayBankLimit
        If ArrayBank[num]
            Return num
        End If
    Next
    
    Return ArrayBankLimit+1
End Function

; incomplete / unimplemented
Function DynamicSmoothArrayBank( ArrayBank[ArrayBankLimit] , Offset,Size )
    Local num,nextnum
    Local endpoint = Offset+Size
    Local endslope = True
    
    num = FindNextNonZero( ArrayBank , Offset )
    If num > endpoint
        Return
    End If
    
    ; pad (slope up) leading section with first value found in a slope
    ; - only if not a perfect fit (first point in graph)
    If num > Offset
        SlopeArrayBank ArrayBank , Offset,num-Offset , 0,ArrayBank[num]
    End If
    
    ; start looking for next points
    Repeat
        nextnum = FindNextNonZero( ArrayBank , num+1 )
        If nextnum > endpoint
            Exit
        ElseIf nextnum = endpoint
            ; no end slope needed (perfect fit)
            endslope = False
        End If
        ; and smooth the space between points
        SlopeArrayBank ArrayBank , num,nextnum-num , ArrayBank[num],ArrayBank[nextnum]
        num = nextnum
    Until num = endpoint
    
    ; the trailing section should be sloped down if zeroes behind last point
    If endslope
        SlopeArrayBank ArrayBank , num,endpoint-num , ArrayBank[num],0
    End If
    
;    Repeat
;    Forever
    
;    For num = Offset To endpoint
;        If ArrayBank[num] <= 0
;            total = total / divisor
;            If total < 0
;                total = 0
;            End If
;        ElseIf ArrayBank[num] >= prevvalue
;            total = ( total + ArrayBank[num] ) / 2
;        End If
;        prevvalue = ArrayBank[num]
;        ArrayBank[num] = total
;    Next
End Function


Function SlopeArrayBank( ArrayBank[ArrayBankLimit] , Offset,Size , Value1,Value2 )
    Local pos,realpos
    Local value_dif = Value2 - Value1
    
    For pos = 1 To Size
        ArrayBank[ pos-1 + Offset ] = Value1 + pos * value_dif / Size
    Next
    
End Function
-->
Posted : Monday, 28 November 2011, 19:55 | Permalink | Mark Here
Scherererer
For some theory, look up convolution, and specifically using a box filter and a gaussian filter. ----- YouTube Twitter Computer Science Series: Logic (pt1) (part 2) (part 3) 2's Complement Mathematics: Basic Differential Calculus