Changeset 1132


Ignore:
Timestamp:
12/05/08 08:33:22 (4 years ago)
Author:
fma
Message:

Use signals for synchronisation

Location:
trunk/papywizard
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/papywizard/controller/shootController.py

    r1120 r1132  
    6464 
    6565from papywizard.common.loggingServices import Logger 
     66from papywizard.common.helpers import sToHmsAsStr 
    6667from papywizard.common.configManager import ConfigManager 
    6768from papywizard.controller.messageController import ErrorMessageController 
    6869from papywizard.controller.abstractController import AbstractController 
    69 #from papywizard.controller.generalInfoController import GeneralInfoController 
    7070from papywizard.controller.configController import ConfigController 
    7171from papywizard.controller.spy import Spy 
    … …  
    7878    def _init(self): 
    7979        self._gladeFile = "shootDialog.glade" 
    80         self._signalDict = {"on_rewindButton_clicked": self.__onRewindButtonclicked, 
     80        self._signalDict = {"on_textViewTogglebutton_toggled": self.__onTextViewTogglebuttonToggled, 
     81                            "on_rewindButton_clicked": self.__onRewindButtonclicked, 
    8182                            "on_forwardButton_clicked": self.__onForwardButtonclicked, 
    8283                            "on_stepByStepCheckbutton_toggled": self.__onStepByStepCheckbuttonToggled, 
    … …  
    117118        self.viewport.add(self.shootingArea) 
    118119        self.shootingArea.show() 
     120         
     121        # Create text shooting area 
     122        self.textShootingArea = gtk.VBox() 
     123        self.position1Label = gtk.Label() 
     124        self.position1Label.modify_font(pango.FontDescription("Arial 18")) 
     125        self.textShootingArea.pack_start(self.position1Label) 
     126        self.position1Label.set_text("--") 
     127        self.position2Label = gtk.Label() 
     128        self.position2Label.modify_font(pango.FontDescription("Arial 18")) 
     129        self.textShootingArea.pack_start(self.position2Label) 
     130        self.position2Label.set_text("") 
     131        self.repeatLabel = gtk.Label() 
     132        self.repeatLabel.modify_font(pango.FontDescription("Arial 18")) 
     133        self.repeatLabel.set_text("--") 
     134        self.textShootingArea.pack_start(self.repeatLabel) 
     135        self.textShootingArea.show_all() 
    119136 
    120137        self.rewindButton = self.wTree.get_widget("rewindButton") 
    … …  
    166183 
    167184        Spy().newPosSignal.connect(self.__refreshPos) 
    168         self._model.newPositionSignal.connect(self.__shootingNewPosition) 
    169185        self._model.startedSignal.connect(self.__shootingStarted) 
    170186        self._model.pausedSignal.connect(self.__shootingPaused) 
    171187        self._model.resumedSignal.connect(self.__shootingResumed) 
    172188        self._model.stoppedSignal.connect(self.__shootingStopped) 
    173         self._model.updateInfoSignal.connect(self.__shootingUpdateInfo) 
     189        self._model.waitingSignal.connect(self.__shootingWaiting) 
     190        self._model.beginShootSignal.connect(self.__shootingBeginShoot) 
     191        self._model.progressSignal.connect(self.__shootingProgress) 
     192        self._model.repeatSignal.connect(self.__shootingRepeat) 
     193        self._model.newPositionSignal.connect(self.__shootingNewPosition) 
     194        self._model.sequenceSignal.connect(self.__shootingSequence) 
     195        self._model.bracketSignal.connect(self.__shootingBracket) 
    174196 
    175197    # Callbacks GTK 
    … …  
    327349                Logger().debug("ShootController.__onMotionNotify(): drag x=%d, y=%d" % (x, y)) 
    328350 
     351    def __onTextViewTogglebuttonToggled(self, widget): 
     352        Logger().trace("ShootController.__onTextViewTogglebuttonToggled()") 
     353        if widget.get_active(): 
     354            self.viewport.remove(self.shootingArea) 
     355            self.viewport.add(self.textShootingArea) 
     356        else: 
     357            self.viewport.remove(self.textShootingArea) 
     358            self.viewport.add(self.shootingArea) 
     359 
    329360    def __onRewindButtonclicked(self, widget): 
    330361        Logger().trace("ShootController.__onRewindButtonclicked()") 
    … …  
    343374        Logger().trace("ShootController.__onDataFileButtonclicked()") 
    344375        controller = ConfigController(self, self._model, self._serializer) 
    345         controller.notebook.set_current_page(5) 
     376        controller.selectPage(5, disable=True) 
    346377        response = controller.run() 
    347378        controller.shutdown() 
    … …  
    349380 
    350381    def __onTimerButtonClicked(self, widget): 
     382        Logger().trace("ShootController.__onTimerButtonClicked()") 
    351383        controller = ConfigController(self, self._model, self._serializer) 
    352         controller.notebook.set_current_page(6) 
     384        controller.selectPage(6, disable=True) 
    353385        response = controller.run() 
    354386        controller.shutdown() 
    … …  
    375407 
    376408    # Callback model (all GUI calls must be done via the serializer) 
    377     def __shootingNewPosition(self, yaw, pitch, status=None, next=False): 
    378         Logger().trace("ShootController.__shootingNewPosition()") 
    379         self.shootingArea.add_pict(yaw, pitch, status, next) 
    380         self._serializer.addWork(self.shootingArea.refresh) 
    381  
    382409    def __shootingStarted(self): 
    383410        Logger().trace("ShootController.__shootingStarted()") 
    384411        self._serializer.addWork(self.shootingArea.clear) 
     412        self._serializer.addWork(self.progressbar.set_fraction, 0.) 
     413        self._serializer.addWork(self.position1Label.set_text, "--") 
     414        self._serializer.addWork(self.position2Label.set_text, "") 
     415        self._serializer.addWork(self.repeatLabel.set_text, "--") 
    385416        self._serializer.addWork(self.dataFileButton.set_sensitive, False) 
    386417        self._serializer.addWork(self.timerButton.set_sensitive, False) 
    … …  
    417448        self._serializer.addWork(self.timerButton.set_sensitive, True) 
    418449        self._serializer.addWork(self.startButton.set_sensitive, True) 
    419         #self._serializer.addWork(self.pauseResumeLabel.set_text, _("Pause")) 
    420450        self._serializer.addWork(self.pauseResumeButton.set_sensitive, False) 
    421451        self._serializer.addWork(self.stopButton.set_sensitive, False) 
    422452        self._serializer.addWork(self.doneButton.set_sensitive, True) 
    423         #self._serializer.addWork(self.rewindButton.set_sensitive, False) 
    424         #self._serializer.addWork(self.forwardButton.set_sensitive, False) 
    425  
    426     def __shootingUpdateInfo(self, info): 
    427         Logger().debug("ShootController.__shootingUpdateInfo(): info=%s" % info) 
    428         if info.has_key('sequence'): 
    429             self._serializer.addWork(self.progressbar.set_text, info['sequence']) 
    430         elif info.has_key('progress'): 
    431             self._serializer.addWork(self.progressbar.set_fraction, info['progress']) 
     453 
     454    def __shootingWaiting(self, wait): 
     455        Logger().trace("ShootController.__shootingRepeat()") 
     456        sequenceMessage = _("Waiting %s") % sToHmsAsStr(wait) 
     457        self._serializer.addWork(self.progressbar.set_text, sequenceMessage) 
     458 
     459    def __shootingBeginShoot(self): 
     460        Logger().trace("ShootController.__shootingBeginShoot()") 
     461        self._serializer.addWork(self.shootingArea.clear) 
     462 
     463    def __shootingProgress(self, progress): 
     464        Logger().trace("ShootController.__shootingProgress()") 
     465        self._serializer.addWork(self.progressbar.set_fraction, progress) 
     466 
     467    def __shootingRepeat(self, repeat): 
     468        Logger().trace("ShootController.__shootingRepeat()") 
     469        sequenceMessage = _("Repeat #%d of %d") % (repeat, self._model.timerEveryRepeat) 
     470        #self._serializer.addWork(self.progressbar.set_text, sequenceMessage) 
     471        self.repeatLabel.set_text(sequenceMessage) 
     472 
     473    def __shootingNewPosition(self, index, yaw, pitch, status=None, next=False): 
     474        Logger().trace("ShootController.__shootingNewPosition()") 
     475        if isinstance(index, tuple): 
     476            index, yawIndex, pitchIndex = index 
     477            position2 = _("(yaw #%(yawIndex)d of %(yawNbPicts)d, pitch #%(pitchIndex)d of %(pitchNbPicts)d)") 
     478            positionData = {'totalNbPicts': self._model.mosaic.totalNbPicts, 
     479                            'yawNbPicts': self._model.mosaic.yawNbPicts, 
     480                            'pitchNbPicts' : self._model.mosaic.pitchNbPicts} 
     481            positionData.update({'index': index, 'yawIndex': yawIndex, 'pitchIndex': pitchIndex}) 
     482            self._serializer.addWork(self.position2Label.set_text, "%s" % position2 % positionData) 
     483        else: 
     484            positionData = {'totalNbPicts': self._model.preset.totalNbPicts} 
     485            positionData.update({'index': index}) 
     486        #Logger().debug("ShootController.__shootingNewPosition(): %s" % sequence % sequenceData) 
     487        position1 = _("Position #%(index)d of %(totalNbPicts)d") 
     488        self._serializer.addWork(self.position1Label.set_text, "%s" % position1 % positionData) 
     489        self.shootingArea.add_pict(yaw, pitch, status, next) 
     490        self._serializer.addWork(self.shootingArea.refresh) 
     491 
     492    def __shootingSequence(self, sequence, **kwargs): 
     493        Logger().trace("ShootController.__shootingSequence()") 
     494        if sequence == 'moving': 
     495            self._serializer.addWork(self.progressbar.set_text, _("Moving")) 
     496        elif sequence == 'stabilization': 
     497            self._serializer.addWork(self.progressbar.set_text, _("Stabilization")) 
     498        elif sequence == 'mirror': 
     499            self._serializer.addWork(self.progressbar.set_text, _("Mirror lockup")) 
     500        elif sequence == 'shutter': 
     501            bracket = kwargs['bracket'] 
     502            totalNbPicts = self._model.camera.bracketingNbPicts 
     503            self._serializer.addWork(self.progressbar.set_text, _("Shutter cycle - Pict #%d of %d") % (bracket, totalNbPicts)) 
     504 
     505    def __shootingBracket(self, bracket): 
     506        Logger().trace("ShootController.__shootingBracket()") 
     507        sequenceData = {'bracket': bracket, 
     508                        'bracketingNbPicts': self._model.camera.bracketingNbPicts} 
     509        Logger().debug("ShootController.__shootingBracket(): bracket=%(bracket)d of %(bracketingNbPicts)d" % sequenceData) 
     510        #self._serializer.addWork(self.textShootingArea.set_text, "%s" % sequence % sequenceData) 
    432511 
    433512    def __refreshPos(self, yaw, pitch): 
    434         """ Refresh position according to new pos. 
    435  
    436         @param yaw: yaw axis value 
    437         @type yaw: float 
    438  
    439         @param pitch: pitch axix value 
    440         @type pitch: float 
    441         """ 
    442513        Logger().trace("ShootController.__refreshPos()") 
    443514        self.shootingArea.set_current_head_position(yaw, pitch) 
    … …  
    494565        if self.__thread is not None: 
    495566            self.__thread.join() 
    496         self._model.newPositionSignal.disconnect(self.__shootingNewPosition) 
     567        Spy().newPosSignal.disconnect(self.__refreshPos) 
    497568        self._model.startedSignal.disconnect(self.__shootingStarted) 
    498569        self._model.pausedSignal.disconnect(self.__shootingPaused) 
    499570        self._model.resumedSignal.disconnect(self.__shootingResumed) 
    500571        self._model.stoppedSignal.disconnect(self.__shootingStopped) 
    501         self._model.updateInfoSignal.disconnect(self.__shootingUpdateInfo) 
    502         Spy().newPosSignal.disconnect(self.__refreshPos) 
     572        self._model.waitingSignal.disconnect(self.__shootingWaiting) 
     573        self._model.beginShootSignal.disconnect(self.__shootingBeginShoot) 
     574        self._model.progressSignal.disconnect(self.__shootingProgress) 
     575        self._model.repeatSignal.connect(self.__shootingRepeat) 
     576        self._model.newPositionSignal.disconnect(self.__shootingNewPosition) 
     577        self._model.sequenceSignal.disconnect(self.__shootingSequence) 
     578        self._model.bracketSignal.disconnect(self.__shootingBracket) 
    503579 
    504580    def refreshView(self): 
    505         self.dataFileButtonImage.set_sensitive(ConfigManager().getBoolean('Preferences', 'DATA_FILE_ENABLE')) 
    506         self.timerButtonImage.set_sensitive(ConfigManager().getBoolean('Preferences', 'TIMER_EVERY_ENABLE')) 
     581        dataFileFlag = ConfigManager().getBoolean('Preferences', 'DATA_FILE_ENABLE') 
     582        self.dataFileButtonImage.set_sensitive(dataFileFlag) 
     583        timerFlag = ConfigManager().getBoolean('Preferences', 'TIMER_AFTER_ENABLE') or ConfigManager().getBoolean('Preferences', 'TIMER_EVERY_ENABLE') 
     584        self.timerButtonImage.set_sensitive(timerFlag) 

  • trunk/papywizard/model/shooting.py

    r1126 r1132  
    5656 
    5757from papywizard.common import config 
     58from papywizard.common.helpers import hmsAsStrToS, sToHmsAsStr 
    5859from papywizard.common.loggingServices import Logger 
    5960from papywizard.common.signal import Signal 
    … …  
    8081        self.__pause = False 
    8182        self.__stop = False 
    82         self.__manualShoot = False 
     83        self.__stepByStep = False 
    8384        self.__forceNewShootingIndex = False 
    8485        self.__scan = None 
    8586 
     87        # Hardware 
    8688        self.realHardware = realHardware 
    8789        self.simulatedHardware = simulatedHardware 
    8890        self.hardware = self.simulatedHardware 
    8991        self.switchToRealHardwareSignal = Signal() 
    90         self.newPositionSignal = Signal() 
     92 
     93        # Shooting sequence signals 
    9194        self.startedSignal = Signal() 
    9295        self.resumedSignal = Signal() 
    9396        self.pausedSignal = Signal() 
    9497        self.stoppedSignal = Signal() 
    95         self.updateInfoSignal = Signal() 
     98        self.waitingSignal = Signal() 
     99        self.beginShootSignal = Signal() 
     100        self.remainingSignal = Signal() 
     101        self.progressSignal = Signal() 
     102        self.repeatSignal = Signal() 
     103        self.newPositionSignal = Signal() 
     104        self.sequenceSignal = Signal() 
     105        self.bracketSignal = Signal() 
     106 
     107        # Model 
    96108        self.camera = Camera() 
    97109        self.mosaic = MosaicScan(self) 
    98110        self.preset = PresetScan(self) 
    99111 
    100         self.title = "Here goes the title" 
    101         self.gps ="Here goes the location" 
    102         self.comment = "Generated by Papywizard %s" % config.VERSION 
    103  
    104112    # Properties 
    105113    def __getMode(self): 
    … …  
    154162 
    155163    cameraRoll = property(__getCameraRoll, __setCameraRoll) 
     164 
     165    def __getTimerAfter(self): 
     166        """ 
     167        """ 
     168        return hmsAsStrToS(ConfigManager().get('Preferences', 'TIMER_AFTER')) 
     169 
     170    def __setTimerAfter(self, s): 
     171        """ 
     172        """ 
     173        ConfigManager().set('Preferences', 'TIMER_AFTER', sToHmsAsStr(s)) 
     174 
     175    timerAfter = property(__getTimerAfter, __setTimerAfter) 
     176 
     177    def __getTimerAfterEnable(self): 
     178        """ 
     179        """ 
     180        return ConfigManager().getBoolean('Preferences', 'TIMER_AFTER_ENABLE') 
     181 
     182    def __setTimerAfterEnable(self, flag): 
     183        """ 
     184        """ 
     185        ConfigManager().setBoolean('Preferences', 'TIMER_AFTER_ENABLE', flag) 
     186 
     187    timerAfterEnable = property(__getTimerAfterEnable, __setTimerAfterEnable) 
     188 
     189    def __getTimerEvery(self): 
     190        """ 
     191        """ 
     192        return hmsAsStrToS(ConfigManager().get('Preferences', 'TIMER_EVERY')) 
     193 
     194    def __setTimerEvery(self, s): 
     195        """ 
     196        """ 
     197        ConfigManager().set('Preferences', 'TIMER_EVERY', sToHmsAsStr(s)) 
     198 
     199    timerEvery = property(__getTimerEvery, __setTimerEvery) 
     200 
     201    def __getTimerEveryEnable(self): 
     202        """ 
     203        """ 
     204        return ConfigManager().getBoolean('Preferences', 'TIMER_EVERY_ENABLE') 
     205 
     206    def __setTimerEveryEnable(self, flag): 
     207        """ 
     208        """ 
     209        ConfigManager().setBoolean('Preferences', 'TIMER_EVERY_ENABLE', flag) 
     210 
     211    timerEveryEnable = property(__getTimerEveryEnable, __setTimerEveryEnable) 
     212 
     213    def __getTimerEveryRepeat(self): 
     214        """ 
     215        """ 
     216        return ConfigManager().getInt('Preferences', 'TIMER_EVERY_REPEAT') 
     217 
     218    def __setTimerEveryRepeat(self, repeat): 
     219        """ 
     220        """ 
     221        ConfigManager().setInt('Preferences', 'TIMER_EVERY_REPEAT', repeat) 
     222 
     223    timerEveryRepeat = property(__getTimerEveryRepeat, __setTimerEveryRepeat) 
    156224 
    157225    def setStartEndFromFov(self, yawFov, pitchFov): 
    … …  
    230298        @type flag: bool 
    231299        """ 
    232         self.__manualShoot = flag 
     300        self.__stepByStep = flag 
    233301 
    234302    def getShootingIndex(self): 
    … …  
    253321        """ Start pano shooting. 
    254322        """ 
    255         def checkPauseStop(): 
     323        def checkPauseStop(pause=True, stop=True): 
    256324            """ Check if pause or stop requested. 
    257325            """ 
    … …  
    268336 
    269337        Logger().trace("Shooting.start()") 
     338        self.startedSignal.emit() 
     339 
     340        self.__stop = False 
     341        self.__pause = False 
     342        self.__shooting = True 
    270343 
    271344        if self.cameraOrientation == 'portrait': 
    … …  
    277350        else: 
    278351            raise ValueError("cameraOrientation must be in ('portrait', 'landscape', 'custom'") 
    279         values = {'title' : self.title, 
    280                   'gps': self.gps, 
    281                   'comment': self.comment, 
     352        values = {'title' : ConfigManager().get('Preferences', 'DATA_TITLE'), 
     353                  'gps': ConfigManager().get('Preferences', 'DATA_GPS'), 
     354                  'comment': ConfigManager().get('Preferences', 'DATA_COMMENT') % {'version': config.VERSION}, 
    282355                  'headOrientation': "up", 
    283356                  'cameraOrientation': "%s" % self.cameraOrientation, 
    … …  
    292365                  'focal': "%.1f" % self.camera.lens.focal} 
    293366        if self.mode == 'mosaic': 
    294             data = MosaicData() 
    295             values.update({'yawNbPicts': "%d" % self.mosaic.yawNbPicts, 
    296                            'pitchNbPicts': "%d" % self.mosaic.pitchNbPicts, 
    297                            'overlap': "%.2f" % self.mosaic.overlap, 
    298                            'yawRealOverlap': "%.2f" % self.mosaic.yawRealOverlap, 
    299                            'pitchRealOverlap': "%.2f" % self.mosaic.pitchRealOverlap}) 
    300         else: 
    301             data = PresetData() 
    302             values.update({'name': "%s" % self.preset.name}) 
    303         data.createHeader(values) 
    304         self.error = False 
    305         self.progress = 0. 
    306         self.__stop = False 
    307         self.__pause = False 
    308         self.__shooting = True 
    309         self.updateInfoSignal.emit({'progress': 0.}) 
    310         self.startedSignal.emit() 
    311  
    312         # Loop over all positions 
    313         if self.mode == 'mosaic': 
    314367            self.__scan = self.mosaic 
    315368        else: 
    316369            self.__scan = self.preset 
     370 
     371        Logger().info("Starting shoot process...") 
    317372        try: 
    318             Logger().info("Starting shoot process...") 
    319             for index, (yaw, pitch) in self.__scan.iterPositions(): # Use while True + getCurrentPosition()? 
    320                 try: 
    321                     if isinstance(index, tuple): 
    322                         index, yawIndex, pitchIndex = index 
    323                     self.__forceNewShootingIndex = False 
    324                     self.newPositionSignal.emit(yaw, pitch, next=True) # Add index(es) 
    325  
    326                     Logger().info("Moving") 
     373 
     374            # Timer after 
     375            if self.timerAfterEnable: 
     376                initialTime = time.time() 
     377                remainingTime = self.timerAfter - (time.time() - initialTime) 
     378                while remainingTime > 0: 
     379                    Logger().debug("Shooting.start(): start in %s" % sToHmsAsStr(remainingTime)) 
     380                    self.waitingSignal.emit(remainingTime) 
     381                    time.sleep(1) 
     382 
     383                    # Check pause or stop 
     384                    checkPauseStop() 
     385 
     386                    remainingTime = self.timerAfter - (time.time() - initialTime) 
     387 
     388            # Timer repeat 
     389            if self.timerEveryEnable: 
     390                numRepeat =  self.timerEveryRepeat 
     391            else: 
     392                numRepeat = 1 
     393            for repeat in xrange(1, numRepeat + 1): 
     394 
     395                # Create data object 
     396                if self.mode == 'mosaic': 
     397                    Logger().debug("Shooting.start(): create mosaic data object") 
     398                    data = MosaicData() 
     399                    values.update({'yawNbPicts': "%d" % self.mosaic.yawNbPicts, 
     400                                'pitchNbPicts': "%d" % self.mosaic.pitchNbPicts, 
     401                                'overlap': "%.2f" % self.mosaic.overlap, 
     402                                'yawRealOverlap': "%.2f" % self.mosaic.yawRealOverlap, 
     403                                'pitchRealOverlap': "%.2f" % self.mosaic.pitchRealOverlap}) 
     404                else: 
     405                    Logger().debug("Shooting.start(): create preset data object") 
     406                    data = PresetData() 
     407                    values.update({'name': "%s" % self.preset.name}) 
     408                data.createHeader(values) 
     409 
     410                self.beginShootSignal.emit() 
     411                self.progress = 0. 
     412                self.progressSignal.emit(self.progress) 
     413                startTime = time.time() 
     414                Logger().debug("Shooting.start(): repeat %d/%d" % (repeat, numRepeat)) 
     415                self.repeatSignal.emit(repeat) 
     416 
     417                # Loop over all positions 
     418                for index, (yaw, pitch) in self.__scan.iterPositions(): # Use while True + getCurrentPosition()? 
    327419                    try: 
    328                         Logger().debug("Shooting.start(): moving to yaw=%d/%d pitch=%d/%d" % \ 
    329                                           (yawIndex, self.__scan.yawNbPicts, pitchIndex, self.__scan.pitchNbPicts)) 
    330                         self.sequence = _("Moving to yaw=%d/%d pitch=%d/%d" % \ 
    331                                           (yawIndex, self.__scan.yawNbPicts, pitchIndex, self.__scan.pitchNbPicts)) 
    332                     except NameError: 
    333                         Logger().debug("Shooting.start(): moving to %d/%d" % (index, self.__scan.totalNbPicts)) 
    334                         self.sequence = _("Moving to %d/%d" % (index, self.__scan.totalNbPicts)) 
    335                     self.updateInfoSignal.emit({'sequence': self.sequence}) 
    336                     self.hardware.gotoPosition(yaw, pitch) 
    337  
    338                     Logger().info("Stabilization") 
    339                     self.sequence = _("Stabilizing") 
    340                     self.updateInfoSignal.emit({'sequence': self.sequence}) 
    341                     time.sleep(self.stabilizationDelay) 
    342  
    343                     # Test manual shooting flag 
    344                     if self.__manualShoot and not self.__stop: 
    345                         self.__pause = True 
    346                         Logger().info("Wait for manual shooting trigger...") 
    347  
    348                     # Check pause or cancel 
    349                     checkPauseStop() 
    350  
    351                     # If a new shooting position has been requested (from the view), 
    352                     # we force a new iteration to get the new position 
    353                     if self.__forceNewShootingIndex: 
    354                         continue 
    355  
    356                     # Camera shutter cycle 
    357                     for bracket in xrange(self.camera.bracketingNbPicts): 
    358  
    359                         # Mirror lockup sequence 
    360                         if self.camera.mirrorLockup: 
    361                             Logger().info("Mirror lockup") 
    362                             sequence = _("Mirror lockup") 
    363                             self.updateInfoSignal.emit({'sequence': sequence}) 
    364                             self.hardware.shoot(self.stabilizationDelay) 
    365  
    366                         # Shoot 
    367                         Logger().info("Shooting") 
    368                         try: 
    369                             Logger().debug("Shooting.start(): shooting at yaw=%d/%d pitch=%d/%d bkt=%d/%d" % \ 
    370                                      (yawIndex, self.__scan.yawNbPicts, pitchIndex, self.__scan.pitchNbPicts, 
    371                                       bracket + 1, self.camera.bracketingNbPicts)) 
    372                             sequence = _("Shooting at yaw=%d/%d pitch=%d/%d bkt=%d/%d") % \ 
    373                                      (yawIndex, self.__scan.yawNbPicts, pitchIndex, self.__scan.pitchNbPicts, 
    374                                       bracket + 1, self.camera.bracketingNbPicts) 
    375                         except NameError: 
    376                             Logger().debug("Shooting.start(): shooting at %d/%d bkt=%d/%d" % \ 
    377                                            (index, self.__scan.totalNbPicts, bracket + 1, self.camera.bracketingNbPicts)) 
    378                             sequence = _("Shooting at %d/%d bkt=%d/%d") % \ 
    379                                      (index, self.__scan.totalNbPicts, bracket + 1, self.camera.bracketingNbPicts) 
    380                         self.updateInfoSignal.emit({'sequence': sequence}) 
    381                         self.hardware.shoot(self.camera.timeValue) 
    382  
    383                         # Add image to the xml data file 
    384                         data.addPicture(bracket + 1, yaw, pitch, roll) 
    385  
    386                     # Update global shooting progression 
    387                     progressFraction = float(index) / float(self.__scan.totalNbPicts) 
    388                     self.updateInfoSignal.emit({'progress': progressFraction}) 
    389                     self.newPositionSignal.emit(yaw, pitch, status='ok', next=True) 
    390  
    391                     # Test manual shooting flag 
    392                     if self.__manualShoot and not self.__stop: 
    393                         self.__pause = True 
    394                         Logger().info("Wait for manual shooting trigger...") 
    395  
    396                     # Check pause or cancel 
    397                     checkPauseStop() 
    398                      
    399                     if not self.__forceNewShootingIndex: 
    400                         self.newPositionSignal.emit(yaw, pitch, status='ok', next=False) 
    401  
    402                 except HardwareError: 
    403                     self.hardware.stopAxis() 
    404                     Logger().exception("Shooting.start()") 
    405                     Logger().warning("Shooting.start(): position (yaw=%.1f, pitch=%.1f) out of limits" % (yaw, pitch)) 
    406  
    407                     progressFraction = float(index) / float(self.__scan.totalNbPicts) 
    408                     self.updateInfoSignal.emit({'progress': progressFraction}) 
    409                     self.newPositionSignal.emit(yaw, pitch, status='error', next=True) 
    410  
    411                     # Test manual shooting flag 
    412                     if self.__manualShoot and not self.__stop: 
    413                         self.__pause = True 
    414                         Logger().info("Wait for manual shooting trigger...") 
    415  
    416                     # Check pause or cancel 
    417                     checkPauseStop() 
    418                      
    419                     if not self.__forceNewShootingIndex: 
    420                         self.newPositionSignal.emit(yaw, pitch, status='error', next=False) 
     420 
     421                        Logger().debug("Shooting.start(): position index=%s, yaw=%.1f, pitch=%.1f" % (str(index), yaw, pitch)) 
     422                        self.__forceNewShootingIndex = False 
     423                        self.newPositionSignal.emit(index, yaw, pitch, next=True) 
     424 
     425                        Logger().info("Moving") 
     426                        self.sequenceSignal.emit('moving') 
     427                        self.hardware.gotoPosition(yaw, pitch) 
     428 
     429                        Logger().info("Stabilization") 
     430                        self.sequenceSignal.emit('stabilization') 
     431                        time.sleep(self.stabilizationDelay) 
     432 
     433                        # Test manual shooting flag 
     434                        if self.__stepByStep and not self.__stop: 
     435                            self.__pause = True 
     436                            Logger().info("Wait for manual shooting trigger...") 
     437 
     438                        # Check pause or stop 
     439                        checkPauseStop() 
     440 
     441                        # If a new shooting position has been requested (rewind/forward), 
     442                        # we force a new iteration to get the new position 
     443                        if self.__forceNewShootingIndex: 
     444                            continue 
     445 
     446                        # Take pictures 
     447                        for bracket in xrange(1, self.camera.bracketingNbPicts + 1): 
     448 
     449                            # Mirror lockup sequence 
     450                            if self.camera.mirrorLockup: 
     451                                Logger().info("Mirror lockup") 
     452                                self.sequenceSignal.emit('mirror') 
     453                                self.hardware.shoot(self.stabilizationDelay) 
     454 
     455                            # Take pictures 
     456                            Logger().info("Shutter cycle") 
     457                            Logger().debug("Shooting.start(): pict #%d of %d" % (bracket, self.__scan.totalNbPicts)) 
     458                            #self.bracketSignal.emit(bracket) 
     459                            self.sequenceSignal.emit('shutter', bracket=bracket) 
     460                            self.hardware.shoot(self.camera.timeValue) 
     461 
     462                            # Add image to the xml data file 
     463                            data.addPicture(bracket, yaw, pitch, roll) 
     464 
     465                            # Check pause or stop 
     466                            checkPauseStop() 
     467 
     468                        # Update global shooting progression 
     469                        if isinstance(index, tuple): 
     470                            index2, yawIndex, pitchIndex = index 
     471                        else: 
     472                            index2 = index 
     473                        progressFraction = float(index2) / float(self.__scan.totalNbPicts) 
     474                        self.progressSignal.emit(progressFraction) 
     475                        self.newPositionSignal.emit(index, yaw, pitch, status='ok', next=True) 
     476 
     477                        # Test manual shooting flag 
     478                        if self.__stepByStep and not self.__stop: 
     479                            self.__pause = True 
     480                            Logger().info("Wait for manual shooting trigger...") 
     481 
     482                        # Check pause or stop 
     483                        checkPauseStop() 
     484 
     485                        if not self.__forceNewShootingIndex: 
     486                            self.newPositionSignal.emit(index, yaw, pitch, status='ok', next=False) 
     487 
     488                    except HardwareError: 
     489                        self.hardware.stopAxis() 
     490                        Logger().exception("Shooting.start()") 
     491                        Logger().warning("Shooting.start(): position index=%s, yaw=%.1f, pitch=%.1f out of limits" % (yaw, pitch)) 
     492 
     493                        if isinstance(index, tuple): 
     494                            index2, yawIndex, pitchIndex = index 
     495                        else: 
     496                            index2 = index 
     497                        progressFraction = float(index2) / float(self.__scan.totalNbPicts) 
     498                        self.newPositionSignal.emit(index, yaw, pitch, status='error', next=True) 
     499 
     500                        # Test manual shooting flag 
     501                        if self.__stepByStep and not self.__stop: 
     502                            self.__pause = True 
     503                            Logger().info("Wait for manual shooting trigger...") 
     504 
     505                        # Check pause or stop 
     506                        checkPauseStop() 
     507 
     508                        if not self.__forceNewShootingIndex: 
     509                            self.newPositionSignal.emit(yaw, pitch, status='error', next=False) 
     510 
     511                if repeat < numRepeat: 
     512                    remainingTime = self.timerEvery - (time.time() - startTime) 
     513                    while remainingTime > 0: 
     514                        Logger().debug("Shooting.start(): restart in %s" % sToHmsAsStr(remainingTime)) 
     515                        self.waitingSignal.emit(remainingTime) 
     516                        time.sleep(1) 
     517 
     518                        # Check pause or stop 
     519                        checkPauseStop() 
     520 
     521                        remainingTime = self.timerEvery - (time.time() - startTime) 
    421522 
    422523        except StopIteration: 
Note: See TracChangeset for help on using the changeset viewer.