def __init__(self, observer):
"""
Inicializa e cria uma nova instância do objeto.
:param observer Instância a ser salva.
"""
self.obj = observer
self.total = Point(*observer.total)
self.lt = Point(*observer.lt)
self.rb = Point(*observer.rb)
def drawtext(self):
"""
Desenha os textos informados sobre os elementos
indicados anteriormente.
:return:
"""
xsize = (self.cellsize * self.rel[0]).x
fsz = min(.75, (xsize / 80) * .75)
if xsize < 45:
return
for elem, text in self.text.iteritems():
elem = self.im.access(elem)
if elem in self.selection:
continue
tl, br = elem.border()
p0 = (tl * self.rel[0])(round)(int)
p1 = (br * self.rel[0])(round)(int)
pf = Point(p0.x, p1.y) + (10, -10)
color = self.tcolor[elem.pos]
cv.putText(self.actual.raw, text, pf, cv.FONT_HERSHEY_SIMPLEX, fsz,
color, 2, cv.CV_AA)
def lDown(self, canvas, e):
"""
Callback para o evento de mouse LEFT_DOWN.
:param canvas Campo de exibição de imagens
:param e Dados do evento.
"""
self._mstart = Point(e.GetX(), e.GetY())
self._mark = canvas.im.mark()
self._move = 0
e.Skip()
def __init__(self, image, cellsize, shape = (800, 600)):
"""
Inicializa e cria uma nova instância do objeto.
:param image Image a ser exibida.
:param cellsize Tamanho de cada célula da grade.
:param shape Formato do campo de visão para a imagem.
:return GridSpectator
"""
Spectator.__init__(self, image, shape)
self.cellsize = Point(*cellsize)
self.grid = False
def __init__(self, psize, *image):
"""
Inicializa uma nova instância do objeto.
:param psize Tamanho dos retalhos.
:param image Imagens a serem recortadas e manipuladas por retalhos.
:return PatchWork
"""
fpsz = float(psize[0]), float(psize[1])
List.__init__(self, *image)
Grid.__init__(self, *map(ceil, self.shape / fpsz))
self.psize = Point(*psize)
def __init__(self, lpwork, elem, pos, psize):
"""
Inicializa uma nova instância do objeto.
:param lpwork Colcha de retalhos em camadas que contém esse retalho.
:param elem Posição do elemento no gradeado.
:param pos Posição do retalho sobre a imagem.
:param psize Tamanho do retalho sobre a imagem.
:return Patch
"""
List.__init__(self, *[Patch(im, elem, pos, psize) for im in lpwork])
Element.__init__(self, lpwork, elem)
self.psize = Point(*psize)
def __init__(self, image, shape=(800, 600)):
"""
Inicializa e cria uma nova instância do objeto.
:param image Imagem a ser exibida.
:param shape Formato do campo de visão para a imagem.
:return Spectator
"""
self.shape = Point(*shape)
self.actual = self.im = image
# Relações de tamanhos.
# rel[0]: proporção tamanho original -> tamanho atual
# rel[1]: proporção tamanho atual -> tamanho original
self.rel = (1, 1)
self.total = self.im.shape
self.lt = (self.total - self.shape) // 2
self.rb = (self.total + self.shape) // 2
def generate(self):
"""
Cria uma imagem baseada nos elementos selecionados para
segmentação avulsa.
:return Image
"""
x0 = min(self.selected, key=lambda e: e.pos.x).pos.x
y0 = min(self.selected, key=lambda e: e.pos.y).pos.y
x1 = max(self.selected, key=lambda e: e.pos.x).pos.x
y1 = max(self.selected, key=lambda e: e.pos.y).pos.y
xdiff = x1 - x0
ydiff = y1 - y0
psize = self.parent.im.psize
self.diff = Point(x0, y0)
img = Image.new(((1 + xdiff) * psize.x, (1 + ydiff) * psize.y))
pwork = PatchWork(psize, img)
pwork.shred(0)
for elem in self.selected:
pwork.access((elem.pos - self.diff)).sew(elem[1])
return pwork