self.hsv=(0,0,0)

		self.pos=(0,0)

		self.m=0

		self._boards=[]

		self._dirty=False

		self._createGUI()

	def sample(self,e):

		try:

			(r,g,b)=(x/255 for x in self.img.getpixel((e.x,e.y)))

		except IndexError:

			return

		(h,s,v)=map(lambda x: round(x,3), rgb_to_hsv(r,g,b))

		self.hsv=(h,s,v)

		self.pos=(e.x,e.y)

		self.posLabel.configure(text="({0},{1})".format(e.x,e.y))

		self.colorLabel.configure(text="HSV: ({0}, {1}, {2})".format(round(h*360),s,v))

	def printSample(self):

		print("\t".join(map(str, (self.filenames[self.k],*self.pos,self.letter,*self.hsv))))

	def showImage(self):

		(w,h)=self.img.size

		self.photo=ImageTk.PhotoImage(self.img)

		self.canvas.delete("all")

		self.canvas.create_image(0,0,image=self.photo,anchor="nw")

		self.canvas.configure(width=w,height=h)

		self.m=0

		self.isGrid=False

		f=self.filename

		if f in self.annotations:

			self._boards=self.annotations[f]+[Board()]

		else:

			self._boards=[Board()]

		self._markCorners()

	def switchImage(self,step):

		self.save()

		n=len(self.filenames)

		self.k=(self.k+step+n)%n

		self.showImage()

	def switchCorners(self,step):

		n=len(self._boards)

		self.m=(self.m+step+n)%n

		self.isGrid=not self.isGrid

		self._markCorners()

	def deleteBoard(self):

		self._boards.pop(self.m)

		self._flush()

		self._dirty=True

		self.showImage()

	def addCorner(self,e):

		self.corners.add(e.x,e.y)

		self._flush()

		self._dirty=True

		self._markCorners()

	def save(self):

		if self._dirty:

			self.annotations.save()

			self._dirty=False

	def _flush(self):

		self.annotations[self.filename]=[b for b in self._boards if not b.isEmpty()]

	def _createGUI(self):

		frame=tk.Frame(root)

		frame.grid(column=0,row=0,sticky=(N,S,E,W))

		self.canvas=tk.Canvas(frame)

		self.canvas.grid(row=1,column=0)

		bar=self._createBar(frame)

		bar.grid(row=2,column=0,sticky=(E,W))

		self.showImage()

		self.canvas.bind('<1>',lambda e: self.printSample())

		self.canvas.bind('<3>',self.addCorner)

		self.canvas.bind("<Motion>",self.sample)

		root.bind("<Left>",lambda e: self.switchImage(-1))

		root.bind("<Right>",lambda e: self.switchImage(1))

		root.bind("<Up>",lambda e: self.switchCorners(-1))

		root.bind("<Down>",lambda e: self.switchCorners(1))

		root.bind("<b>",lambda e: self.setLetter("b"))

		root.bind("<e>",lambda e: self.setLetter("e"))

		root.bind("<w>",lambda e: self.setLetter("w"))

		root.bind("<Key-period>",lambda e: self.switchAsterisk())

		root.bind("<Key-comma>",lambda e: self.switchGrid())

		root.bind("<d>",lambda e: self.deleteBoard())

import os

import sys

import re

import random

import numpy as np

import cv2 as cv

sys.path.append("..")

sys.path.append("../../src")

from annotations import DataFile,computeBoundingBox,Corners,EPoint

from geometry import Line

from kerokero.transformation_matrices import getIdentity,getRotation,getTranslation,getScale,getMirroring,getProjection

random.seed(361)

class Sample:

	SIDE=224

	def __init__(self,img,grid):

		""":param img: a greyscale image as a 2D np.uint8

		:param grid: iterable of 4 EPoints, ie. Corners"""

		self.img=img

		self.grid=grid

	def transform(self):

		""":return: (img, grid), where img is a 2D np.float32 with values in (0,1),

		grid [(float) x, (float) y, ...], with x, y in (-1,1)"""

		center=self._getCenter()

		m=getIdentity()

		t1=getTranslation(-center.x,-center.y)

		proj=getProjection()

		rot=getRotation()

		mir=getMirroring()

		for mi in [t1,mir,proj,rot]:

			m=np.matmul(mi,m)

		m=np.matmul(self._computeCrop(m),m)

		img=cv.warpPerspective(self.img,m,(self.SIDE,self.SIDE))

		img=np.float32(img)/128-1

		grid=Corners(c.transform(m) for c in self.grid)

		return (img,grid)

	def _getCenter(self):

		(a,b,c,d)=self.grid

		p=Line.fromPoints(a,c)

		q=Line.fromPoints(b,d)

		return p.intersect(q)

	def _computeCrop(self,m):

		grid=Corners(c.transform(m) for c in self.grid)

		(x1,y1,x2,y2)=computeBoundingBox(grid)

		(wg,hg)=(x2-x1,y2-y1)

		(left,top,right,bottom)=[random.uniform(0.05,0.2) for i in range(4)]

		t2=getTranslation(left*wg-x1, top*hg-y1)

		scale=getScale(self.SIDE/(wg*(1+left+right)), self.SIDE/(hg*(1+top+bottom)))

		return np.matmul(scale,t2)

	def show(self):

		img=cv.cvtColor(self.img,cv.COLOR_GRAY2BGR)

		for c in self.grid:

			cv.circle(img,(int(c.x),int(c.y)),3,[0,255,0],-1)

		show(img)