"""

Data structure and convertors for a table of (device,attr,value)

rows. These might be effect attrs ('strength'), device attrs ('rx'),

or output attrs (dmx channel).

"""

import decimal

from rdflib import URIRef, Literal

from light9.namespaces import RDF, L9, DEV

from light9.rdfdb.patch import Patch

def getVal(graph, subj):

    lit = graph.value(subj, L9['value']) or graph.value(subj, L9['scaledValue'])

    ret = lit.toPython()

    if isinstance(ret, decimal.Decimal):

        ret = float(ret)

    return ret

class _Settings(object):

    """

    comparisons will break.

    """

    def __init__(self, graph, settingsList):

        self.graph = graph # for looking up all possible attrs

        for row in settingsList:

            self._compiled.setdefault(row[0], {})[row[1]] = row[2]

        # self._compiled may not be final yet- see _fromCompiled

        self._delZeros()

    @classmethod

    def _fromCompiled(cls, graph, compiled):

        obj = cls(graph, [])

        obj._compiled = compiled

        obj._delZeros()

        return obj

        settingsList = []

        with graph.currentState() as g:

            for s in g.objects(subj, L9['setting']):

                d = g.value(s, L9['device'])

                da = g.value(s, L9['deviceAttr'])

                v = getVal(g, s)

                settingsList.append((d, da, v))

        return cls(graph, settingsList)

    @classmethod

    def fromVector(cls, graph, vector):

        compiled = {}

            compiled.setdefault(d, {})[a] = v

        return cls._fromCompiled(graph, compiled)

    def _delZeros(self):

        for dev, av in self._compiled.items():

            for attr, val in av.items():

                    del av[attr]

            if not av:

                del self._compiled[dev]

    def __hash__(self):

        itemed = tuple([(d, tuple([(a, v) for a, v in sorted(av.items())]))

                        for d, av in sorted(self._compiled.items())])

        return hash(itemed)

    def __eq__(self, other):

        if not issubclass(other.__class__, self.__class__):

            raise TypeError("can't compare %r to %r" % (self.__class__, other.__class__))

        return self._compiled == other._compiled

    def __ne__(self, other):

        return not self == other

    def __repr__(self):

        words = []

        def accum():

            for dev, av in self._compiled.iteritems():

                for attr, val in av.iteritems():

                                               attr.rsplit('/')[-1],

                                               val))

                    if len(words) > 5:

                        words.append('...')

                        return

        accum()

        return '<%s %s>' % (self.__class__.__name__, ' '.join(words))

    def getValue(self, dev, attr):

    def _vectorKeys(self):

        """stable order of all the dev,attr pairs for this type of settings"""

        raise NotImplementedError

    def asList(self):

        """old style list of (dev, attr, val) tuples"""

        out = []

        for dev, av in self._compiled.iteritems():

            for attr, val in av.iteritems():

                out.append((dev, attr, val))

        return out

    def devices(self):

        return self._compiled.keys()

    def toVector(self):

        out = []

        for dev, attr in self._vectorKeys():

        return out

    def byDevice(self):

        for dev, av in self._compiled.iteritems():

            yield dev, self.__class__._fromCompiled(self.graph, {dev: av})

    def ofDevice(self, dev):

        return self.__class__._fromCompiled(self.graph,

                                            {dev: self._compiled.get(dev, {})})

    def distanceTo(self, other):

    def statements(self, subj, ctx, settingRoot, settingsSubgraphCache):

        """

        settingRoot can be shared across images (or even wider if you want)

        """

        # ported from live.coffee

        add = []

        for i, (dev, attr, val) in enumerate(self.asList()):

            # hopefully a unique number for the setting so repeated settings converge

            settingHash = hash((dev, attr, val)) % 9999999

            setting = URIRef('%sset%s' % (settingRoot, settingHash))

            add.append((subj, L9['setting'], setting, ctx))

from light9.rdfdb.patch import Patch

from light9.rdfdb.localsyncedgraph import LocalSyncedGraph

from light9.namespaces import RDF, L9, DEV

from light9.effect.settings import DeviceSettings

class TestDeviceSettings(unittest.TestCase):

    def setUp(self):

        self.graph = LocalSyncedGraph(files=['show/dance2017/cam/test/lightConfig.n3',

                                             'show/dance2017/cam/test/bg.n3'])

    def testToVectorZero(self):

        ds = DeviceSettings(self.graph, [])

    def testEq(self):

        s1 = DeviceSettings(self.graph, [

            (L9['light1'], L9['attr1'], 0.5),

            (L9['light1'], L9['attr2'], 0.3),

        ])

        s2 = DeviceSettings(self.graph, [

            (L9['light1'], L9['attr2'], 0.3),

            (L9['light1'], L9['attr1'], 0.5),

        ])

        self.assertTrue(s1 == s2)

        self.assertFalse(s1 != s2)

            (L9['foo_set1'], L9['scaledValue'], Literal(0.2), ctx),

        ]))

        s = DeviceSettings.fromResource(self.graph, L9['foo'])

        self.assertEqual(DeviceSettings(self.graph, [

            (L9['light1'], L9['brightness'], 0.1),

            (L9['light1'], L9['speed'], 0.2),

        ]), s)

    def testToVector(self):

        v = DeviceSettings(self.graph, [

            (DEV['aura1'], L9['rx'], 0.5),

        ]).toVector()

        self.assertEqual(

    def testFromVector(self):

        s = DeviceSettings.fromVector(

            self.graph,

        self.assertEqual(DeviceSettings(self.graph, [

            (DEV['aura1'], L9['rx'], 0.5),

        ]), s)                            

    def testAsList(self):

        sets = [

            (L9['light1'], L9['attr2'], 0.3),

            (L9['light1'], L9['attr1'], 0.5),

        ]

        self.assertItemsEqual(sets, DeviceSettings(self.graph, sets).asList())

    def testDevices(self):

        s = DeviceSettings(self.graph, [

            ])

        # aura1 is all defaults (zeros), so it doesn't get listed

    def testAddStatements(self):

        s = DeviceSettings(self.graph, [

            ])

        stmts = s.statements(L9['foo'], L9['ctx1'], L9['s_'], set())

        self.maxDiff=None

        self.assertItemsEqual([

        ], stmts)

from __future__ import division

from light9.namespaces import RDF, L9, DEV

from PIL import Image

import numpy

import scipy.misc, scipy.ndimage, scipy.optimize

import cairo

# numpy images in this file are (x, y, c) layout.

def numpyFromCairo(surface):

    w, h = surface.get_width(), surface.get_height()

    a = numpy.frombuffer(surface.get_data(), numpy.uint8)

    a.shape = h, w, 4

    a = a.transpose((1, 0, 2))

    return a[:w,:h,:3]

def numpyFromPil(img):

    return scipy.misc.fromimage(img, mode='RGB').transpose((1, 0, 2))

def loadNumpy(path, thumb=(100, 100)):

    img = Image.open(path)

    img.thumbnail(thumb)

    return numpyFromPil(img)

def saveNumpy(path, img):

    scipy.misc.imsave(path, img.transpose((1, 0, 2)))

def scaledHex(h, scale):

    rgb = parseHex(h)

    rgb8 = (rgb * scale).astype(numpy.uint8)

    return '#%02x%02x%02x' % tuple(rgb8)

def colorRatio(col1, col2):

    rgb1 = parseHex(col1)

    rgb2 = parseHex(col2)

    return tuple([round(a / b, 3) for a, b in zip(rgb1, rgb2)])

def brightest(img):

    return numpy.amax(img, axis=(0, 1))

        self.sampleSettings = {} # (uri, path): DeviceSettings

    def loadSamples(self):

        """learn what lights do from images"""

        with self.graph.currentState() as g:

            for samp in g.subjects(RDF.type, L9['LightSample']):

                base = g.value(samp, L9['path']).toPython()

                path = 'show/dance2017/cam/test/%s' % base

                self.samples[samp] = self.fromPath[base] = loadNumpy(path)

                self.blurredSamples[samp] = self._blur(self.samples[samp])

                self.sampleSettings[key] = DeviceSettings.fromResource(self.graph, samp)

    def _blur(self, img):

        return scipy.ndimage.gaussian_filter(img, 10, 0, mode='nearest')

    def draw(self, painting, w, h):

        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, w, h)

        ctx = cairo.Context(surface)

        ctx.rectangle(0, 0, w, h)

        ctx.fill()

        ctx.set_line_cap(cairo.LINE_CAP_ROUND)

            dist = numpy.sum(numpy.absolute(pic0Blur - picSample), axis=None)

            sampleDist[sample] = dist

        results = [(d, uri) for uri, d in sampleDist.items()]

        results.sort()

        sample = results[0][1]

        # this is wrong; some wrong-alignments ought to be dimmer than full

        brightest0 = brightest(pic0)

        brightestSample = brightest(self.samples[sample])

        if max(brightest0) < 1 / 255:

        scale = brightest0 / brightestSample

        s = DeviceSettings.fromResource(self.graph, sample)

        # missing color scale, but it was wrong to operate on all devs at once

        return s

    def solveBrute(self, painting):

        pic0 = self.draw(painting, 100, 48).astype(numpy.float)

        colorSteps = 3

        colorStep = 1. / colorSteps

        dims = [

            (DEV['aura1'], L9['rx'], [slice(.2, .7+.1, .1)]),

            (DEV['aura1'], L9['ry'], [slice(.573, .573+1, 1)]),

            (DEV['aura1'], L9['color'], [slice(0, 1 + colorStep, colorStep),

                                         slice(0, 1 + colorStep, colorStep),

                                         slice(0, 1 + colorStep, colorStep)]),

        ]

        def drawError(x):

            settings = DeviceSettings.fromVector(self.graph, x)

            preview = self.combineImages(self.simulationLayers(settings))

            saveNumpy('/tmp/x_%s.png' % abs(hash(settings)), preview)

            diff = preview.astype(numpy.float) - pic0

            out = scipy.sum(abs(diff))

            #print 'measure at', x, 'drawError=', out

            return out

        x0, fval, grid, Jout = scipy.optimize.brute(

import unittest

import numpy.testing

import solve

from light9.namespaces import RDF, L9, DEV

from light9.rdfdb.localsyncedgraph import LocalSyncedGraph

from light9.effect.settings import DeviceSettings

class TestSolve(unittest.TestCase):

    def setUp(self):

        self.solver = solve.Solver(self.graph)

        self.solver.loadSamples()

        self.solveMethod = self.solver.solve

    def testBlack(self):

        devAttrs = self.solveMethod({'strokes': []})

        self.assertEqual(DeviceSettings(self.graph, []), devAttrs)

    def testSingleLightCloseMatch(self):

        devAttrs = self.solveMethod({'strokes': [{'pts': [[224, 141],

                                                 [223, 159]],

                                         'color': '#ffffff'}]})

            (DEV['aura1'], L9['color'], u"#ffffff"),

            (DEV['aura1'], L9['rx'], 0.5 ),

            (DEV['aura1'], L9['ry'], 0.573),

        ]), devAttrs)

class TestSolveBrute(TestSolve):

    def setUp(self):

        super(TestSolveBrute, self).setUp()

        self.solveMethod = self.solver.solveBrute

class TestSimulationLayers(unittest.TestCase):

    def setUp(self):

        self.solver = solve.Solver(self.graph)

        self.solver.loadSamples()

    def testBlack(self):

        self.assertEqual(

            [],

            self.solver.simulationLayers(settings=DeviceSettings(self.graph, [])))

    def testPerfect1Match(self):

        layers = self.solver.simulationLayers(settings=DeviceSettings(self.graph, [

            (DEV['aura1'], L9['color'], u"#ffffff"),

            (DEV['aura1'], L9['rx'], 0.5 ),

            (DEV['aura1'], L9['ry'], 0.573),

            (DEV['aura2'], L9['color'], u"#ffffff"),

            (DEV['aura2'], L9['rx'], 0.7 ),

            (DEV['aura2'], L9['ry'], 0.573),

        ]))

        self.assertItemsEqual([

            {'path': 'bg2-d.jpg', 'color': (1, 1, 1)},

            {'path': 'bg2-f.jpg', 'color': (1, 1, 1)},

                      ], layers)

class TestCombineImages(unittest.TestCase):

    def setUp(self):

        self.solver = solve.Solver(graph)

        self.solver.loadSamples()

    def test(self):

        out = self.solver.combineImages(layers=[

            {'path': 'bg2-d.jpg', 'color': (.2, .2, .3)},

            {'path': 'bg2-a.jpg', 'color': (.888, 0, .3)},

        ])

        solve.saveNumpy('/tmp/t.png', out)

        golden = solve.loadNumpy('show/dance2017/cam/test/layers_out1.png')

        numpy.testing.assert_array_equal(golden, out)