Another maths question

[BrewManNH]

your way takes nearly always 15 frames per second.

 

That's because the $TargetFramesPerSecond is set to 15, change that number, update the _AvarageScreenshotTime function to not save the files either, and I can get around 50-55 frames taken in one second.

Func _AvarageScreenshotTime($NunShots)
    Local $aShots[$NunShots]

    For $I = 0 To $NunShots - 1
        $Timer = TimerInit()
        _ScreenCapture_Capture("", 0, 0, 100, 100) ; don't save the screen shots
        $Diff = TimerDiff($Timer)
        $aShots[$I] = $Diff
    Next

;~  FileDelete("pic.bmp")

    $Total = 0

    For $I = 0 To $NunShots - 1
        $Total += ($aShots[$I])
    Next

    $average = $Total / $NunShots

    Return Floor($average)

EndFunc   ;==>_AvarageScreenshotTime

[JohnOne]

Here's a much better option, instead of saving the files every time through the loop, get the $hBMP handle and store it in an array. After you've taken all of your screen shots, then save them all to disk, this way the function doesn't have to waste time saving files before returning and can return as soon as possible.

expandcollapse popup

#include <Screencapture.au3>
#include <File.au3>

;Create a temp folder in script dir if it does not exist
Const $CaptureFolder = @ScriptDir & "\capture\"
If Not FileExists($CaptureFolder) Then
    DirCreate($CaptureFolder)
EndIf

;Some variables
Const $OneSecond = 1000
Const $TargetFramesPerSecond = 15
$Iterator = 0

;Some Calculations.
$AvaerageShoTime = _AvarageScreenshotTime(200)
$Calc1 = $AvaerageShoTime * $TargetFramesPerSecond
$Calc2 = 1000 - $Calc1
$Sleep = $Calc2 / $TargetFramesPerSecond

;Loop for approx one second
$Timer = TimerInit()
Global $aCap[1000]
While TimerDiff($Timer) <= $OneSecond

    $aCap[$Iterator] =  _ScreenCapture_Capture("", 0, 0, 100, 100)

    ;Just for file name
    $Iterator += 1

    Sleep($Sleep)
WEnd
ReDim $aCap[$Iterator]
For $I = 0 To UBound($aCap) - 1
    _ScreenCapture_SaveImage($CaptureFolder & $I & ".bmp", $aCap[$I])
Next

$aFiles = _FileListToArray($CaptureFolder, "*.bmp", 1)
If @error Then
    ;Remove files and folders
    _RemoveDir()
    Exit MsgBox(0, 0, "Error")
EndIf

;Amount of images created
$CURRENT_FPS = Int($aFiles[0])
MsgBox(0, "Files", "Captured " & $CURRENT_FPS & " images in 1 second")

_RemoveDir()

Func _RemoveDir()
    FileDelete($CaptureFolder & "*")
    For $I = 1 To 10
        $Removed = DirRemove($CaptureFolder)
        If $Removed Then
            ExitLoop
        EndIf
        Sleep(100)
    Next
    MsgBox(0, "Removed Folder", ($Removed = 1))
EndFunc   ;==>_RemoveDir

Func _AvarageScreenshotTime($NunShots)
    Local $aShots[$NunShots]

    For $I = 0 To $NunShots - 1
        $Timer = TimerInit()
        _ScreenCapture_Capture("pic.bmp", 0, 0, 100, 100)
        $Diff = TimerDiff($Timer)
        $aShots[$I] = $Diff
    Next

    FileDelete("pic.bmp")

    $Total = 0

    For $I = 0 To $NunShots - 1
        $Total += ($aShots[$I])
    Next

    $average = $Total / $NunShots

    Return Floor($average)

EndFunc   ;==>_AvarageScreenshotTime

You'll have to adjust your averagescreenshotime function to accomodate that method. I've gotten up to 50+ screenshots using this, and as low as 40.

 

Thanks.

was thinking about the same as other script, the capturing could go on for some time, and could quickly fill memory with large images.

[BrewManNH]

I suppose you could pause it for a few seconds to write the contents to disk and dispose of the memory used by the images, the default of _ScreenCapture_SaveImage is to free the $hBitMap handle when it writes to disk. It depends on if you need to worry about that momentary pause in the screen captures needed to write them to disk. The writes don't take that long for small files, but would obviously take longer with larger images, you could time that process as well with the actual images you want to save, and also check memory usage after a long period of time.

[czardas]

What is the movie JO? You only need one screen capture for idle time when nothing happens, say between mouse clicks.

Edited September 12, 2014 by czardas

[JohnOne]

If I want to animate a series of images at say 10 fps, I only want to capture 10 fps at regular intervals. Could be anything on the screen.

Currently I cannot find a way to get close to that.

Closes I have so far is the following.

$n in loop is the Target fps.

expandcollapse popup

#include <Screencapture.au3>
#include <File.au3>

;Const $AimFrames = 20

;Create a temp folder in script dir if it does not exist
Const $CaptureFolder = @ScriptDir & "\capture\"
If Not FileExists($CaptureFolder) Then
    DirCreate($CaptureFolder)
EndIf

$ShotTime = _AvarageScreenshotTime(100)

$Tune = $ShotTime / 1.2

For $n = 10 To 50
    _Main($n, $ShotTime, $Tune)
    ;Sleep(1000)
Next

Func _Main($TargetFramesPerSecond, $AvaerageShotTime, $FineTune)
    ;Some variables
    Const $OneSecond = 1000

    $Iterator = 1


    ;Some Calculations.

    _Debug($AvaerageShotTime, "$AvaerageShotTime")
    $Calc1 = $AvaerageShotTime * $TargetFramesPerSecond
    _Debug($Calc1, "$Calc1")
    $Calc2 = 1000 - $Calc1
    _Debug($Calc2, "$Calc2")
    $Calc3 = $Calc2 / $TargetFramesPerSecond
    _Debug($Calc3, "$Calc3")
    $Sleep = Ceiling($Calc3 - $FineTune)
    _Debug($Sleep, "$Sleep")

    ;Loop for approx one second
    $Timer = TimerInit()
    While TimerDiff($Timer) <= $OneSecond

        $Cap = _ScreenCapture_Capture($CaptureFolder & $Iterator & ".bmp", 0, 0, 100, 100)

        ;Just for file name
        $Iterator += 1

        Sleep($Sleep)
    WEnd

    Local $aFiles = _FileListToArray($CaptureFolder, "*.bmp", 1)
    If @error Then

        ;Remove files and folders
        If Not _RemoveDir() Then
            Exit MsgBox(0, 0, "Error _RemoveDir")
        EndIf
        Exit MsgBox(0, 0, "Error _FileListToArray")
    EndIf

    ;Amount of images created
    $CURRENT_FPS = Int($aFiles[0])
    ConsoleWrite("Target = " & $TargetFramesPerSecond &  " - Captured " & $CURRENT_FPS & " images in 1 second")

    _RemoveDir()
EndFunc   ;==>_Main

Func _Debug($val, $varname)
    ConsoleWrite($varname & " = " & $val & @LF)
EndFunc   ;==>_Debug

Func _RemoveDir()
    FileDelete($CaptureFolder & "*")
    #cs
    For $i = 1 To 10
        $Removed = DirRemove($CaptureFolder)
        If $Removed Then
            ExitLoop
        EndIf
        Sleep(100)
    Next
    Return ($Removed = 0)
    #ce
EndFunc   ;==>_RemoveDir

Func _AvarageScreenshotTime($NunShots)
    Local $aShots[$NunShots]

    For $i = 0 To $NunShots - 1
        $Timer = TimerInit()
        _ScreenCapture_Capture("pic.bmp", 0, 0, 100, 100)
        $Diff = TimerDiff($Timer)
        $aShots[$i] = $Diff
    Next

    FileDelete("pic.bmp")

    $Total = 0

    For $i = 0 To $NunShots - 1
        $Total += ($aShots[$i])
    Next

    $average = $Total / $NunShots

    Return Floor($average)

EndFunc   ;==>_AvarageScreenshotTime

$Tune is something I was trying to get a better result, it's not bad but somewhere between 30 and 50 fps it can go way off capturing +- 10 fps which is no good +- 2 or 3 would be fine.

[czardas]

Have you tried running several scripts at once. You could trigger them to each take a single screen shot in turn (or several captures in a timed sequence) using a master timer script. It might work and it might not - it's just an idea.

Edited September 12, 2014 by czardas

[jdelaney]

No amount of timing will work.  Processes are variable, so it's impossible to esitmate within a reasonable timeframe.  That's with calling a second script, or sleeping.

I still think you should rapid fire, and then delete extra, logically.

Edited September 12, 2014 by jdelaney

[czardas]

Have you tried it? Sleep is not reliable enough - you need to use timers. Calling the script is also no good. You need some kind of super fast trigger to get any reasonable kind of synchronization. Maybe it can be done by adding a delay to the internal clock time. Although I fear you may be right and the result may not be a smooth transition.

Edited September 12, 2014 by czardas

[JohnOne]

Still taking a look at UEZ' AVI script, see if I get a more stable capture time from that.

[czardas]

You can reduce interrupts a little bit by closing as many processes as possible before the capture process begins.

[JohnOne]

Have you tried it? Sleep is not reliable enough - you need to use timers.

That's way better.

 

$Tune = 0

$sTimer = TimerInit()
Do
Until TimerDiff($sTimer) >= $Sleep
;Sleep($Sleep)

Much better results.

[czardas]

Just be careful of CPU temperature running hot, whatever you do.

If you can get away with putting a 10 milisecond sleep value in the loop, then you probably should.

Edited September 12, 2014 by czardas

[JohnOne]

Be interested to see what other machines get if anyone can be bothered.

Form the below script I got...

Target = 10 - Captured 11

Target = 11 - Captured 11
Target = 12 - Captured 12
Target = 13 - Captured 13
Target = 14 - Captured 14
Target = 15 - Captured 15
Target = 16 - Captured 16
Target = 17 - Captured 17
Target = 18 - Captured 18
Target = 19 - Captured 19
Target = 20 - Captured 20
Target = 21 - Captured 21
Target = 22 - Captured 22
Target = 23 - Captured 23
Target = 24 - Captured 24
Target = 25 - Captured 25
Target = 26 - Captured 26
Target = 27 - Captured 26
Target = 28 - Captured 27
Target = 29 - Captured 28
Target = 30 - Captured 30
Target = 31 - Captured 31
Target = 32 - Captured 31
Target = 33 - Captured 33
Target = 34 - Captured 34
Target = 35 - Captured 35
Target = 36 - Captured 36
Target = 37 - Captured 36
Target = 38 - Captured 37
Target = 39 - Captured 39
Target = 40 - Captured 40
Target = 41 - Captured 41
Target = 42 - Captured 42
Target = 43 - Captured 41
Target = 44 - Captured 43
Target = 45 - Captured 43
Target = 46 - Captured 45
Target = 47 - Captured 46
Target = 48 - Captured 48
Target = 49 - Captured 48
Target = 50 - Captured 50

expandcollapse popup

#include <Screencapture.au3>
#include <File.au3>

Const $AimFrames = 20

;Create a temp folder in script dir if it does not exist
Const $CaptureFolder = @ScriptDir & "\capture\"
If Not FileExists($CaptureFolder) Then
    DirCreate($CaptureFolder)
EndIf

$ShotTime = _AvarageScreenshotTime(100)

$Tune = 1;$ShotTime / 1.2

For $n = 10 To 50
    _Main($n, $ShotTime, $Tune)
    ;Sleep(1000)
Next

Func _Main($TargetFramesPerSecond, $AvaerageShotTime, $FineTune)
    ;Some variables
    Const $OneSecond = 1000

    $Iterator = 1


    ;Some Calculations.

    ;_Debug($AvaerageShotTime, "$AvaerageShotTime")
    $Calc1 = $AvaerageShotTime * $TargetFramesPerSecond
    ;_Debug($Calc1, "$Calc1")
    $Calc2 = 1000 - $Calc1
    ;_Debug($Calc2, "$Calc2")
    $Calc3 = $Calc2 / $TargetFramesPerSecond
    ;;_Debug($Calc3, "$Calc3")
    $Sleep = Ceiling($Calc3 - $FineTune)
    ;_Debug($Sleep, "$Sleep")

    If $TargetFramesPerSecond >= 30 Then
            $Sleep -= $Tune
        EndIf

    ;Loop for approx one second
    $Timer = TimerInit()
    While TimerDiff($Timer) <= $OneSecond

        $Cap = _ScreenCapture_Capture($CaptureFolder & $Iterator & ".bmp", 0, 0, 100, 100)

        ;Just for file name
        $Iterator += 1


        $sTimer = TimerInit()
        Do
        Until TimerDiff($sTimer) >= $Sleep
        ;Sleep($Sleep)
    WEnd

    Local $aFiles = _FileListToArray($CaptureFolder, "*.bmp", 1)
    If @error Then

        ;Remove files and folders
        If Not _RemoveDir() Then
            Exit MsgBox(0, 0, "Error _RemoveDir")
        EndIf
        Exit MsgBox(0, 0, "Error _FileListToArray")
    EndIf

    ;Amount of images created
    $CURRENT_FPS = Int($aFiles[0])
    ConsoleWrite("Target = " & $TargetFramesPerSecond & " - Captured " & $CURRENT_FPS & @LF)

    _RemoveDir()
EndFunc   ;==>_Main

Func _Debug($val, $varname)
    ConsoleWrite($varname & " = " & $val & @LF)
EndFunc   ;==>_Debug

Func _RemoveDir()
    FileDelete($CaptureFolder & "*")
    #cs
        For $i = 1 To 10
        $Removed = DirRemove($CaptureFolder)
        If $Removed Then
        ExitLoop
        EndIf
        Sleep(100)
        Next
        Return ($Removed = 0)
    #ce
EndFunc   ;==>_RemoveDir

Func _AvarageScreenshotTime($NunShots)
    Local $aShots[$NunShots]

    For $i = 0 To $NunShots - 1
        $Timer = TimerInit()
        _ScreenCapture_Capture("pic.bmp", 0, 0, 100, 100)
        $Diff = TimerDiff($Timer)
        $aShots[$i] = $Diff
    Next

    FileDelete("pic.bmp")

    $Total = 0

    For $i = 0 To $NunShots - 1
        $Total += ($aShots[$i])
    Next

    $average = $Total / $NunShots

    Return Floor($average)

EndFunc   ;==>_AvarageScreenshotTime

[trancexx]

Can't you do something like this, without calculating that average thing:

;...

;Loop for approx one second
    $Timer = TimerInit()
    While TimerDiff($Timer) <= $OneSecond
        $hAnotherTimer = TimerInit()
        $Cap = _ScreenCapture_Capture($CaptureFolder & $Iterator & ".bmp", 0, 0, 100, 100)
        ;Just for file name
        $Iterator += 1
        Sleep(1000 / $AimFrames - TimerDiff($hAnotherTimer))
    WEnd

;...

[UEZ]

In battery mode:

expandcollapse popup

Target = 10 - Captured 12
Target = 11 - Captured 14
Target = 12 - Captured 15
Target = 13 - Captured 19
Target = 14 - Captured 20
Target = 15 - Captured 20
Target = 16 - Captured 20
Target = 17 - Captured 29
Target = 18 - Captured 30
Target = 19 - Captured 30
Target = 20 - Captured 30
Target = 21 - Captured 31
Target = 22 - Captured 31
Target = 23 - Captured 50
Target = 24 - Captured 60
Target = 25 - Captured 60
Target = 26 - Captured 61
Target = 27 - Captured 58
Target = 28 - Captured 60
Target = 29 - Captured 60
Target = 30 - Captured 60
Target = 31 - Captured 60
Target = 32 - Captured 60
Target = 33 - Captured 60
Target = 34 - Captured 54
Target = 35 - Captured 59
Target = 36 - Captured 60
Target = 37 - Captured 60
Target = 38 - Captured 50
Target = 39 - Captured 53
Target = 40 - Captured 56
Target = 41 - Captured 57
Target = 42 - Captured 55
Target = 43 - Captured 59
Target = 44 - Captured 48
Target = 45 - Captured 60
Target = 46 - Captured 46
Target = 47 - Captured 21
Target = 48 - Captured 28
Target = 49 - Captured 46
Target = 50 - Captured 61

On power:

expandcollapse popup

Target = 10 - Captured 10
Target = 11 - Captured 10
Target = 12 - Captured 12
Target = 13 - Captured 12
Target = 14 - Captured 14
Target = 15 - Captured 15
Target = 16 - Captured 16
Target = 17 - Captured 15
Target = 18 - Captured 16
Target = 19 - Captured 17
Target = 20 - Captured 19
Target = 21 - Captured 20
Target = 22 - Captured 14
Target = 23 - Captured 15
Target = 24 - Captured 14
Target = 25 - Captured 19
Target = 26 - Captured 27
Target = 27 - Captured 29
Target = 28 - Captured 30
Target = 29 - Captured 30
Target = 30 - Captured 30
Target = 31 - Captured 30
Target = 32 - Captured 12
Target = 33 - Captured 31
Target = 34 - Captured 31
Target = 35 - Captured 31
Target = 36 - Captured 31
Target = 37 - Captured 31
Target = 38 - Captured 30
Target = 39 - Captured 31
Target = 40 - Captured 32
Target = 41 - Captured 35
Target = 42 - Captured 34
Target = 43 - Captured 47
Target = 44 - Captured 50
Target = 45 - Captured 47
Target = 46 - Captured 55
Target = 47 - Captured 53
Target = 48 - Captured 53
Target = 49 - Captured 56
Target = 50 - Captured 55

Br,

UEZ

[Gianni]

Target = 10 - Captured 11

Target = 11 - Captured 12
Target = 12 - Captured 12
Target = 13 - Captured 14
Target = 14 - Captured 15
Target = 15 - Captured 15
Target = 16 - Captured 15
Target = 17 - Captured 19
Target = 18 - Captured 20
Target = 19 - Captured 19
Target = 20 - Captured 20
Target = 21 - Captured 20
Target = 22 - Captured 19
Target = 23 - Captured 21
Target = 24 - Captured 24
Target = 25 - Captured 29
Target = 26 - Captured 29
Target = 27 - Captured 29
Target = 28 - Captured 30
Target = 29 - Captured 30
Target = 30 - Captured 30
Target = 31 - Captured 29
Target = 32 - Captured 29
Target = 33 - Captured 29
Target = 34 - Captured 30
Target = 35 - Captured 30
Target = 36 - Captured 44
Target = 37 - Captured 45
Target = 38 - Captured 52
Target = 39 - Captured 56
Target = 40 - Captured 58
Target = 41 - Captured 56
Target = 42 - Captured 55
Target = 43 - Captured 58
Target = 44 - Captured 56
Target = 45 - Captured 56
Target = 46 - Captured 57
Target = 47 - Captured 57
Target = 48 - Captured 56
Target = 49 - Captured 57
Target = 50 - Captured 58

[JohnOne]

In battery mode

etc...

UEZ

 

etc...

Well that's that out the window.

[JohnOne]

 

Can't you do something like this, without calculating that average thing:

;...

;Loop for approx one second
    $Timer = TimerInit()
    While TimerDiff($Timer) <= $OneSecond
        $hAnotherTimer = TimerInit()
        $Cap = _ScreenCapture_Capture($CaptureFolder & $Iterator & ".bmp", 0, 0, 100, 100)
        ;Just for file name
        $Iterator += 1
        Sleep(1000 / $AimFrames - TimerDiff($hAnotherTimer))
    WEnd

;...

Just tried a few runs and it's just as unpredictable.

eg

Target = 10 - Captured 10

Target = 11 - Captured 11

Target = 12 - Captured 12

Target = 13 - Captured 13

Target = 14 - Captured 14

Target = 15 - Captured 15

Target = 16 - Captured 16

Target = 17 - Captured 16

Target = 18 - Captured 17

Target = 19 - Captured 18

Target = 20 - Captured 19

Target = 21 - Captured 20

Target = 22 - Captured 21

Target = 23 - Captured 22

Target = 24 - Captured 22

Target = 25 - Captured 24

Target = 26 - Captured 25

Target = 27 - Captured 25

Target = 28 - Captured 26

Target = 29 - Captured 26

Target = 30 - Captured 31

Target = 31 - Captured 29

Target = 32 - Captured 31

Target = 33 - Captured 31

Target = 34 - Captured 31

Target = 35 - Captured 31

Target = 36 - Captured 31

Target = 37 - Captured 31

Target = 38 - Captured 31

Target = 39 - Captured 32

Target = 40 - Captured 34

Target = 41 - Captured 39

Target = 42 - Captured 38

Target = 43 - Captured 44

Target = 44 - Captured 45

Target = 45 - Captured 45

Target = 46 - Captured 44

Target = 47 - Captured 45

Target = 48 - Captured 44

Target = 49 - Captured 45

Target = 50 - Captured 45

Always seems to go skiwiff at around 30fps.

[czardas]

This is what I got from #33 using an earlier AutoIt version.

Target = 10 - Captured 10

Target = 11 - Captured 12
Target = 12 - Captured 12
Target = 13 - Captured 14
Target = 14 - Captured 14
Target = 15 - Captured 15
Target = 16 - Captured 17
Target = 17 - Captured 18
Target = 18 - Captured 18
Target = 19 - Captured 20
Target = 20 - Captured 21
Target = 21 - Captured 22
Target = 22 - Captured 23
Target = 23 - Captured 23
Target = 24 - Captured 25
Target = 25 - Captured 26
Target = 26 - Captured 27
Target = 27 - Captured 27
Target = 28 - Captured 29
Target = 29 - Captured 30
Target = 30 - Captured 32
Target = 31 - Captured 33
Target = 32 - Captured 34
Target = 33 - Captured 35
Target = 34 - Captured 36
Target = 35 - Captured 37
Target = 36 - Captured 38
Target = 37 - Captured 39
Target = 38 - Captured 40
Target = 39 - Captured 42
Target = 40 - Captured 43
Target = 41 - Captured 44
Target = 42 - Captured 46
Target = 43 - Captured 46
Target = 44 - Captured 48
Target = 45 - Captured 48
Target = 46 - Captured 50
Target = 47 - Captured 50
Target = 48 - Captured 52
Target = 49 - Captured 53
Target = 50 - Captured 55

[JohnOne]

If I was to guess, I'd say another cpu core might kick in at about 30fps, but I'd probably be wrong.