Ejemplo n.º 1
0
  def __call__(self, size=10):
      from gamera.core import Image, GREYSCALE, Dim
      result = Image((0, 0), Dim(self.ncols * size, self.nrows * size), GREYSCALE)
      half_size = size / 2
 
      for r in xrange(self.nrows):
          for c in xrange(self.ncols):
              direction = self.get((c, r))
              if self.get((c, r)) != 0:
                  center_r = r * size + (size / 2)
                  size_c = c * size
                  subimage = result.subimage(Point(r*size, c*size), Dim(size, size))
                  dir = half_size * tan(direction)
                  subimage.draw_line((size_c, center_r - dir), (size_c + size, center_r + dir), 128)
      return result
Ejemplo n.º 2
0
    def __doc_example1__(images):
        from random import randint, seed
        from gamera.core import Image, Dim
        seed(0)
        image = Image((0, 0), Dim(320, 300), RGB, DENSE)

        # These are some various Unicode encoded names of different
        # languages (from the wikipedia.org front page).  Just a quick way
        # to test Unicode support.  I use the long encoding here so this
        # source file iteself will be portable.
        names = [
            '\xd0\x91\xd1\x8a\xd0\xbb\xd0\xb3\xd0\xb0\xd1\x80\xd1\x81\xd0\xba\xd0\xb8',
            '\xd7\xa2\xd7\x91\xd7\xa8\xd7\x99\xd7\xaa',
            '\xd8\xa7\xd9\x84\xd8\xb9\xd8\xb1\xd8\xa8\xd9\x8a\xd8\xa9',
            '\xc4\x8cesk\xc3\xa1', 'Rom\xc3\xa2n\xc4\x83',
            '\xe1\x83\xa5\xe1\x83\x90\xe1\x83\xa0\xe1\x83\x97\xe1\x83\xa3\xe1\x83\x9a\xe1\x83\x98',
            '\xd0\x9c\xd0\xb0\xd0\xba\xd0\xb5\xd0\xb4\xd0\xbe\xd0\xbd\xd1\x81\xd0\xba\xd0\xb8',
            '\xc3\x8dslenska', 'Lietuvi\xc5\xb3', 'T\xc3\xbcrk\xc3\xa7e'
        ]

        try:
            for i, name in enumerate(names):
                image.draw_text((160, i * 30),
                                name,
                                RGBPixel(randint(0, 255), randint(0, 255),
                                         randint(0, 255)),
                                20,
                                halign=1)
        except Exception:
            pass
        return image
Ejemplo n.º 3
0
 def __call__(array, offset=(0, 0)):
     from gamera.plugins import _string_io
     from gamera.core import Dim
     pixel_type = from_numeric._check_input(array)
     return _string_io._from_raw_string(
         offset, Dim(array.shape[1], array.shape[0]), pixel_type, DENSE,
         array.tostring())
Ejemplo n.º 4
0
 def extend(self, Ex, Ey, img):
     ul_y = max(0, self.rect.ul_y - Ey)
     ul_x = max(0, self.rect.ul_x - Ex)
     lr_y = min(img.lr_y, self.rect.lr_y + Ey)
     lr_x = min(img.lr_x, self.rect.lr_x + Ex)
     nrows = lr_y - ul_y + 1
     ncols = lr_x - ul_x + 1
     self.rect = Rect(Point(ul_x, ul_y), Dim(ncols, nrows))
Ejemplo n.º 5
0
 def __call__(array, offset=None):
     from gamera.plugins import _string_io
     from gamera.core import Point, Dim
     if offset is None:
         offset = Point(0, 0)
     pixel_type = from_numarray._check_input(array)
     return _string_io._from_raw_string(
         offset, Dim(array.shape[1], array.shape[0]), pixel_type, DENSE,
         array.tostring())
Ejemplo n.º 6
0
 def __doc_example1__(images):
     from random import randint
     from gamera.core import Image, Dim
     image = Image((0, 0), Dim(100, 100), RGB, DENSE)
     for i in range(10):
         image.draw_circle((randint(0, 100), randint(0, 100)),
                           randint(0, 100),
                           RGBPixel(randint(0, 255), randint(0, 255),
                                    randint(0, 255)), 1.0, 0.1)
     return image
Ejemplo n.º 7
0
 def __doc_example1__(images):
     from random import randint, seed
     from gamera.core import Image, Dim
     seed(0)
     image = Image((0, 0), Dim(100, 100), RGB, DENSE)
     for i in range(10):
         image.draw_filled_rect((randint(0, 100), randint(0, 100)),
                                (randint(0, 100), randint(0, 100)),
                                RGBPixel(randint(0, 255), randint(0, 255),
                                         randint(0, 255)))
     return image
Ejemplo n.º 8
0
def Fudge(o, amount=FUDGE_AMOUNT):
    # For rectangles, just return a new rectangle that is slightly larger
    if isinstance(o, Rect):
        return Rect(Point(int(o.ul_x - amount), int(o.ul_y - amount)),
                    Dim(int(o.ncols + amount * 2), int(o.nrows + amount * 2)))

    # For integers, return one of our "fudge number proxies"
    elif isinstance(o, int):
        return FudgeInt(o, amount)
    elif isinstance(o, float):
        return FudgeFloat(o, amount)
Ejemplo n.º 9
0
 def __doc_example1__(images):
     from random import randint
     from gamera.core import Image, Dim
     image = Image((0, 0), Dim(100, 100), RGB, DENSE)
     points = [(randint(0, 100), randint(0, 100)) for x in range(4)]
     image.draw_bezier(*tuple(list(points) + [RGBPixel(255, 0, 0), 0.1]))
     image.draw_marker(points[0], 7, 0, RGBPixel(0, 0, 255))
     image.draw_marker(points[1], 7, 1, RGBPixel(0, 255, 0))
     image.draw_marker(points[2], 7, 1, RGBPixel(0, 255, 0))
     image.draw_marker(points[3], 7, 0, RGBPixel(0, 0, 255))
     return image
Ejemplo n.º 10
0
    def __call__(image, offset=None):
        from gamera.plugins import _string_io
        from gamera.core import Dim, Point, RGBPixel

        if offset is None:
            offset = Point(0, 0)
        if isinstance(image, cv.cvmat):
            imgcv = cv.CloneMat(image)
            cv.CvtColor(image, imgcv, cv.CV_BGR2RGB)
            return _string_io._from_raw_string(offset,
                                               Dim(imgcv.cols, imgcv.rows),
                                               RGB, DENSE, imgcv.tostring())
        elif isinstance(image, cv.iplimage):
            imgcv = cv.CreateImage(cv.GetSize(image), image.depth,
                                   image.channels)
            cv.CvtColor(image, imgcv, cv.CV_BGR2RGB)
            return _string_io._from_raw_string(offset,
                                               Dim(imgcv.width, imgcv.height),
                                               RGB, DENSE, imgcv.tostring())
        else:
            raise TypeError("Image must be of type cv.cvmat or cv.iplimage")
Ejemplo n.º 11
0
 def __call__(image, offset=None):
     from gamera.plugins import _string_io
     from gamera.core import Dim, Point
     typecode = image.mode
     if offset is None:
         offset = Point(0, 0)
     if typecode in _inverse_modes:
         pixel_type = _inverse_modes[typecode]
     else:
         raise ValueError(
             "Only RGB and 8-bit Greyscale 'L' PIL image modes are supported."
         )
     try:
         return _string_io._from_raw_string(
             offset, Dim(image.size[0], image.size[1]), pixel_type,
             DENSE, image.tobytes())
     except Exception:
         # for compatibility with pil 1.1.7 and earlier
         return _string_io._from_raw_string(
             offset, Dim(image.size[0], image.size[1]), pixel_type,
             DENSE, image.tostring())
Ejemplo n.º 12
0
 def __call__(image, offset=None):
     from gamera.plugins import _string_io
     from gamera.core import Dim, Point
     typecode = image.mode
     if offset is None:
         offset = Point(0, 0)
     if _inverse_modes.has_key(typecode):
         pixel_type = _inverse_modes[typecode]
     else:
         raise ValueError(
             "Only RGB and 8-bit Greyscale 'L' PIL image modes are supported."
         )
     return _string_io._from_raw_string(
         offset, Dim(image.size[0], image.size[1]), pixel_type, DENSE,
         image.tostring())
Ejemplo n.º 13
0
    def __call__(self,
                 p,
                 text,
                 color,
                 size=10,
                 font_family=0,
                 italic=False,
                 bold=False,
                 halign=0):
        from gamera.core import Dim, RGB, ONEBIT, Image
        from gamera.plugins import string_io
        try:
            import wx
        except ImportError:
            raise RuntimeError("Drawing text requires wxPython.")
        try:
            dc = wx.MemoryDC()
        except wx._core.PyNoAppError:
            app = wx.App()
            dc = wx.MemoryDC()
        if font_family < 0 or font_family > 2:
            raise ValueError("font_family must be in range 0-2.")
        font_family = [wx.ROMAN, wx.SWISS, wx.MODERN][font_family]
        italic = (italic and wx.ITALIC) or wx.NORMAL
        bold = (bold and wx.BOLD) or wx.NORMAL
        if type(text) == str:
            encoding = wx.FONTENCODING_SYSTEM
        elif type(text) == unicode:
            encoding = wx.FONTENCODING_UNICODE
        else:
            raise ValueError("text must be a string or unicode string.")
        font = wx.Font(size, font_family, italic, bold, encoding=encoding)
        font.SetPixelSize(wx.Size(size * 2, size * 2))
        dc.SetFont(font)
        w, h = dc.GetTextExtent(text)

        # Do the actual drawing
        bmp = wx.EmptyBitmap(w, h, -1)
        dc.SelectObject(bmp)
        dc.SetPen(wx.TRANSPARENT_PEN)
        dc.SetBrush(wx.WHITE_BRUSH)
        dc.DrawRectangle(0, 0, w, h)
        dc.SetBrush(wx.BLACK_BRUSH)
        dc.DrawText(text, 0, 0)
        img = bmp.ConvertToImage()
        img_str = img.GetData()

        text_image = string_io._from_raw_string((0, 0), Dim(w, h), RGB, 0,
                                                img_str)
        text_image = text_image.to_onebit()
        if halign == 1:
            p = (p[0] - w / 2, p[1])
        elif halign == 2:
            p = (p[0] - w, p[1])

        ul = (max(p[0], self.ul_x), max(p[1], self.ul_y))
        lr = (min(p[0] + w, self.lr_x), min(p[1] + h, self.lr_y))
        w = lr[0] - ul[0]
        h = lr[1] - ul[1]
        if w < 0 or h < 0:
            return

        text_image = text_image.subimage(
            (max(self.ul_x - p[0], 0), max(self.ul_y - p[1], 0)), Dim(w, h))
        if self.data.pixel_type == ONEBIT:
            subimage = self.subimage(ul, Dim(w, h))
            if color:
                subimage.or_image(text_image, in_place=True)
            else:
                text_image.invert()
                subimage.and_image(text_image, in_place=True)
        elif self.data.pixel_type == RGB:
            subimage = Image(
                (max(ul[0] - self.ul_x, p[0]), max(ul[1] - self.ul_y, p[1])),
                Dim(w, h), ONEBIT)
            subimage.or_image(text_image, in_place=True)
            self.highlight(subimage, color)
Ejemplo n.º 14
0
def expand_ccs(image,ccs,Ex,Ey):
    # two helper functions for merging rectangles
    def find_intersecting_rects(glyphs, index):
        g = glyphs[index]
        inter = []
        for i in range(len(glyphs)):
            if i == index:
                continue
            if g.intersects(glyphs[i]):
                inter.append(i)
        return inter
    def list_union_rects(big_rects):
        current = 0
        rects = big_rects
        while(1):
            inter = find_intersecting_rects(rects, current)
            if len(inter):
                g = rects[current]
                new_rects = [g]
                for i in range(len(rects)):
                    if i == current:
                        continue
                    if i in inter:
                        g.union(rects[i])
                    else:
                        new_rects.append(rects[i])
                rects = new_rects
                current = 0
            else:
                current += 1
            if(current >= len(rects)):
                break
        return rects

    # the actual plugin
    from gamera.core import Dim, Rect, Point, Cc
    from gamera.plugins.image_utilities import union_images
    page = image

    # extend CC bounding boxes
    big_rects = []
    for c in ccs:
        ul_y = max(0, c.ul_y - Ey)
        ul_x = max(0, c.ul_x - Ex)
        lr_y = min(page.lr_y, c.lr_y + Ey)
        lr_x = min(page.lr_x, c.lr_x + Ex)
        nrows = lr_y - ul_y + 1
        ncols = lr_x - ul_x + 1
        big_rects.append(Rect(Point(ul_x, ul_y), Dim(ncols, nrows)))
    extended_segs = list_union_rects(big_rects)

    # build new merged CCs
    tmplist = ccs[:]
    dellist = []
    seg_ccs = []
    seg_cc = []
    if(len(extended_segs) > 0):
        label = 1
        for seg in extended_segs:
            label += 1
            for cc in tmplist:
                if(seg.intersects(cc)):
                    # mark original image with segment label
                    #self.highlight(cc, label)
                    seg_cc.append(cc)
                    dellist.append(cc)
            if len(seg_cc) == 0:
                continue
            seg_rect = seg_cc[0].union_rects(seg_cc)
            new_seg = Cc(image, label, seg_rect.ul, seg_rect.lr)
            seg_cc = []
            for item in dellist:
                tmplist.remove(item)
            dellist = []
            seg_ccs.append(new_seg)
    return seg_ccs
Ejemplo n.º 15
0
 def get(self):
     from gamera.core import Dim
     return Dim(int(self.control_x.GetValue()),
                int(self.control_y.GetValue()))
Ejemplo n.º 16
0
 def __doc_example1__(images):
   from gamera.core import Dim
   onebit = images[ONEBIT].subimage((0, 0), Dim(70, 68))
   greyscale = images[GREYSCALE].to_onebit().subimage((0, 0), Dim(70, 68))
   return [onebit, greyscale, onebit.and_image(greyscale, False)]