from light9.namespaces import L9, DEV

from PIL import Image

import numpy

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

import cairo

import logging

    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 loadNumpy(path, thumb=(100, 100)):

    img = Image.open(path)

    img.thumbnail(thumb)

    return numpyFromPil(img)

def saveNumpy(path, img):

    # maybe this should only run if log level is debug?

def scaledHex(h, scale):

    rgb = parseHex(h)

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

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

    def __init__(self, img1):

        self.a = img1

        self.maxDist = img1.shape[0] * img1.shape[1] * img1.shape[2] * 255

    def distanceTo(self, img2):

class Solver(object):

        self.graph = graph

        self.sessions = sessions  # URIs of capture sessions to load

        self.imgSize = imgSize

        self.samples = {}  # uri: Image array (float 0-255)

        self.fromPath = {}  # imagePath: image array

        self.path = {}  # sample: path

    def loadSamples(self):

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

        log.info('loading...')

        with self.graph.currentState() as g:

                for cap in g.objects(sess, L9['capture']):

                    self._loadSample(g, cap)

        log.info('loaded %s samples', len(self.samples))

    def _loadSample(self, g, samp):

        pathUri = g.value(samp, L9['imagePath'])

        #saveNumpy('/tmp/best_in.png', img)

        #saveNumpy('/tmp/best_out.png', topImg)

        #saveNumpy('/tmp/mult.png', topImg / 255 * img)

        return topUri, topDist

        """settings for the given devices that point them each

        at the input image"""

        dist = ImageDist(img)

        devSettings = []

            results = []

            for samp, img2 in self.samplesForDevice[dev]:

                results.append((dist.distanceTo(img2), samp))

            results.sort()

            devSettings.append(s)

        return DeviceSettings.fromList(self.graph, devSettings)

    def blendResults(self, results):

        """list of (dist, settings)"""

        remappedDists = [1 - (d - lo) / (hi - lo) * n / (n + 1) for d in dists]

        total = sum(remappedDists)

        #print 'blend'

        #for o,n in zip(dists, remappedDists):

        #    print o,n, n / total

        return blend

    def solve(self, painting):

        """

        given strokes of colors on a photo of the stage, figure out the

        best light DeviceSettings to match the image

        """

        pic0Blur = self._blur(pic0)

        sampleDist = {}

        dist = ImageDist(pic0Blur)

        for sample, picSample in sorted(self.blurredSamples.items()):

            #saveNumpy('/tmp/sample_%s.png' % sample.split('/')[-1],

            #          f(picSample))

            sampleDist[sample] = dist.distanceTo(picSample)

        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):

        colorSteps = 2

        colorStep = 1. / colorSteps

        # use toVector then add ranges

        dims = [

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

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

        ]

        deviceAttrFilter = [(d, a) for d, a, s in dims]

        dist = ImageDist(pic0)

        def drawError(x):

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

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

            out = dist.distanceTo(preview)

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

            return out

        if fval > 30000:

            raise ValueError('solution has error of %s' % fval)

    def combineImages(self, layers):

        """make a result image from our self.samples images"""

        out = (next(iter(self.fromPath.values())) * 0).astype(numpy.uint16)

        for layer in layers:

            colorScaled = self.fromPath[layer['path']] * layer['color']

                log.info('  candidate pic %s %s dist=%s', sample, path, dist)

                candidatePics.append((dist, path, s.getValue(dev, L9['color'])))

            candidatePics.sort()

            # we could even blend multiple top candidates, or omit all

            # of them if they're too far

            bestDist, bestPath, bestPicColor = candidatePics[0]

        return layers

import unittest

import numpy.testing

from . import solve

from rdflib import Namespace

from light9.namespaces import L9, DEV

from light9.effect.settings import DeviceSettings

class TestSolve(unittest.TestCase):

    def setUp(self):

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

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

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

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

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

            ]))

            {

                'path': CAM_TEST['bg2-d.jpg'],

                'color': (1, 1, 1)

            },

            {

                'path': CAM_TEST['bg2-f.jpg'],

            files=['test/cam/lightConfig.n3', 'test/cam/bg.n3'])

        self.solver = solve.Solver(graph,

                                   imgSize=(100, 48),

                                   sessions=[L9['session0']])

        self.solver.loadSamples()

        out = self.solver.combineImages(layers=[

            {

                'path': CAM_TEST['bg2-d.jpg'],

                'color': (.2, .2, .3)

            },

            {

                "color": "#aaaaaa"

            }]

        }

        drawImg = self.solver.draw(drawingOnRight)

        match, dist = self.solver.bestMatch(drawImg)

        self.assertEqual(L9['sample5'], match)