view bin/captureDevice @ 1568:5da62d53e12f

turn inlineattrs back on Ignore-this: f8e015224d2882ba2dbb54d1d6234fe7
author Drew Perttula <drewp@bigasterisk.com>
date Thu, 25 May 2017 06:14:58 +0000
parents 48609cc508e8
children 2239d5648932
line wrap: on
line source

#!bin/python
from __future__ import division
from rdflib import URIRef
from twisted.internet import reactor
from twisted.internet.defer import inlineCallbacks, Deferred

import logging
import optparse
import os
import time
import treq
import cyclone.web, cyclone.websocket, cyclone.httpclient
from greplin import scales

from run_local import log
from lib.cycloneerr import PrettyErrorHandler

from light9.namespaces import L9
from light9 import networking, showconfig
from light9.rdfdb.syncedgraph import SyncedGraph
from light9.paint.capture import writeCaptureDescription
from light9.greplin_cyclone import StatsForCyclone
from light9.effect.settings import DeviceSettings
from light9.effect.sequencer import sendToCollector

stats = scales.collection('/webServer', scales.PmfStat('setAttr'))


class Camera(object):
    def __init__(self, imageUrl):
        self.imageUrl = imageUrl
    
    def takePic(self, uri, writePath):
        log.info('takePic %s', uri)
        return treq.get(self.imageUrl).addCallbacks(lambda r: self._done(writePath, r),
                                                    log.error)
        
    @inlineCallbacks
    def _done(self, writePath, response):
        jpg = yield response.content()
        try:
            os.makedirs(os.path.dirname(writePath))
        except OSError:
            pass
        with open(writePath, 'w') as out:
            out.write(jpg)
        log.info('wrote %s', writePath)


class Capture(object):
    firstMoveTime = 5
    settleTime = .5
    def __init__(self, graph):
        self.graph = graph
        
        def steps(a, b, n):
            return [round(a + (b - a) * i / n, 5) for i in range(n)]

        startTime = time.time()
        self.captureId = 'cap%s' % (int(startTime) - 1495170000)
        self.toGather = []

        row = 0
        for ry in steps(0.85, .92, 6):
            xSteps = steps(.24, .45, 12)
            if row % 2:
                xSteps.reverse()
            row += 1
            for rx in xSteps:
                self.toGather.append(DeviceSettings(graph, [
                    (L9['device/moving1'], L9['rx'], rx),
                    (L9['device/moving1'], L9['ry'], ry),
                ]))

        self.numPics = 0
        self.settingsCache = set()
        self.step().addErrback(log.error)
        
    @inlineCallbacks
    def step(self):
        if not self.toGather:
            reactor.stop()
            return
        settings = self.toGather.pop()
        
        log.info('move to %r', settings)
        yield sendToCollector(client='captureDevice', session='main', settings=settings)
        
        d = Deferred()
        reactor.callLater(self.firstMoveTime if self.numPics == 0 else self.settleTime,
                          d.callback, None)
        yield d
        dev = settings.devices()[0]

        devTail = dev.rsplit('/')[-1]
        
        picId = 'pic%s' % self.numPics
        path = '/'.join(['capture', devTail, self.captureId, picId])
        ctx = URIRef('/'.join([showconfig.showUri(), 'capture', devTail, self.captureId,
                               'index']))
        uri = URIRef('/'.join([showconfig.showUri(), 'capture', devTail, self.captureId,
                               picId]))
                     
        relOutPath = path + '.jpg'
        
        yield camera.takePic(uri, os.path.join(showconfig.root(), relOutPath))
        self.numPics += 1

        writeCaptureDescription(self.graph, ctx, uri, dev, relOutPath,
                                self.settingsCache, settings)
        
        reactor.callLater(0, self.step)

        

camera = Camera('http://dash:8200/picamserve/pic?res=480&resize=480&rotation=180&iso=800&redgain=1.6&bluegain=2&shutter=60000')

class Attrs(PrettyErrorHandler, cyclone.web.RequestHandler):
    def put(self):
        with stats.setAttr.time():
            client, clientSession, settings, sendTime = parseJsonMessage(self.request.body)
            self.set_status(202)

def launch(graph):

    cap = Capture(graph)
    reactor.listenTCP(networking.captureDevice.port,
                      cyclone.web.Application(handlers=[
                          (r'/()', cyclone.web.StaticFileHandler,
                           {"path" : "light9/web", "default_filename" : "captureDevice.html"}),
                          (r'/stats', StatsForCyclone),
                      ]),
                      interface='::')
    log.info('serving http on %s', networking.captureDevice.port)
    
def main():
    parser = optparse.OptionParser()
    parser.add_option("-v", "--verbose", action="store_true",
                      help="logging.DEBUG")
    (options, args) = parser.parse_args()
    log.setLevel(logging.DEBUG if options.verbose else logging.INFO)

    graph = SyncedGraph(networking.rdfdb.url, "captureDevice")

    graph.initiallySynced.addCallback(lambda _: launch(graph)).addErrback(log.error)
    reactor.run()

if __name__ == '__main__':
    main()