# A binary morphology add-on for the Python Imaging Library # # History: # 2014-06-04 Initial version. # # Copyright (c) 2014 Dov Grobgeld from PIL import Image from PIL import _imagingmorph import re LUT_SIZE = 1<<9 class LutBuilder: """A class for building MorphLut's from a descriptive language The input patterns is a list of a strings sequences like these: 4:(... .1. 111)->1 (whitespaces including linebreaks are ignored). The option 4 descibes a series of symmetry operations (in this case a 4-rotation), the pattern is decribed by: . or X - Ignore 1 - Pixel is on 0 - Pixel is off The result of the operation is described after "->" string. The default is to return the current pixel value, which is returned if no other match is found. Operations: 4 - 4 way rotation N - Negate 1 - Dummy op for no other operation (an op must always be given) M - Mirroring Example: lb = LutBuilder(patterns = ["4:(... .1. 111)->1"]) lut = lb.build_lut() """ def __init__(self,patterns = None,op_name=None): if patterns is not None: self.patterns = patterns else: self.patterns = [] self.lut = None if op_name is not None: known_patterns = { 'corner' : ['1:(... ... ...)->0', '4:(00. 01. ...)->1'], 'dilation4' : ['4:(... .0. .1.)->1'], 'dilation8' : ['4:(... .0. .1.)->1', '4:(... .0. ..1)->1'], 'erosion4' : ['4:(... .1. .0.)->0'], 'erosion8' : ['4:(... .1. .0.)->0', '4:(... .1. ..0)->0'], 'edge' : ['1:(... ... ...)->0', '4:(.0. .1. ...)->1', '4:(01. .1. ...)->1'] } if not op_name in known_patterns: raise Exception('Unknown pattern '+op_name+'!') self.patterns = known_patterns[op_name] def add_patterns(self, patterns): self.patterns += patterns def build_default_lut(self): symbols = [0, 1] m = 1 << 4 # pos of current pixel self.lut = bytearray([symbols[(i & m)>0] for i in range(LUT_SIZE)]) def get_lut(self): return self.lut def _string_permute(self, pattern, permutation): """string_permute takes a pattern and a permutation and returns the string permuted accordinging to the permutation list. """ assert(len(permutation)==9) return ''.join([pattern[p] for p in permutation]) def _pattern_permute(self, basic_pattern, options, basic_result): """pattern_permute takes a basic pattern and its result and clones the mattern according to the modifications described in the $options parameter. It returns a list of all cloned patterns.""" patterns = [(basic_pattern, basic_result)] # rotations if '4' in options: res = patterns[-1][1] for i in range(4): patterns.append( (self._string_permute(patterns[-1][0], [6,3,0, 7,4,1, 8,5,2]), res)) # mirror if 'M' in options: n = len(patterns) for pattern,res in patterns[0:n]: patterns.append( (self._string_permute(pattern, [2,1,0, 5,4,3, 8,7,6]), res)) # negate if 'N' in options: n = len(patterns) for pattern,res in patterns[0:n]: # Swap 0 and 1 pattern = (pattern .replace('0','Z') .replace('1','0') .replace('Z','1')) res = '%d'%(1-int(res)) patterns.append((pattern, res)) return patterns def build_lut(self): """Compile all patterns into a morphology lut. TBD :Build based on (file) morphlut:modify_lut """ self.build_default_lut() patterns = [] # Parse and create symmetries of the patterns strings for p in self.patterns: m = re.search(r'(\w*):?\s*\((.+?)\)\s*->\s*(\d)', p.replace('\n','')) if not m: raise Exception('Syntax error in pattern "'+p+'"') options = m.group(1) pattern = m.group(2) result = int(m.group(3)) # Get rid of spaces pattern= pattern.replace(' ','').replace('\n','') patterns += self._pattern_permute(pattern, options, result) # # Debugging # for p,r in patterns: # print p,r # print '--' # compile the patterns into regular expressions for speed for i in range(len(patterns)): p = patterns[i][0].replace('.','X').replace('X','[01]') p = re.compile(p) patterns[i] = (p, patterns[i][1]) # Step through table and find patterns that match. # Note that all the patterns are searched. The last one # caught overrides for i in range(LUT_SIZE): # Build the bit pattern bitpattern = bin(i)[2:] bitpattern = ('0'*(9-len(bitpattern)) + bitpattern)[::-1] for p,r in patterns: if p.match(bitpattern): self.lut[i] = [0, 1][r] return self.lut class MorphOp: """A class for binary morphological operators""" def __init__(self, lut=None, op_name = None, patterns = None): """Create a binary morphological operator""" self.lut = lut if op_name is not None: self.lut = LutBuilder(op_name = op_name).build_lut() elif patterns is not None: self.lut = LutBuilder(patterns = patterns).build_lut() def apply(self, image): """Run a single morphological operation on an image Returns a tuple of the number of changed pixels and the morphed image""" if self.lut is None: raise Exception('No operator loaded') outimage = Image.new(image.mode, image.size, None) count = _imagingmorph.apply(str(self.lut), image.im.id, outimage.im.id) return count, outimage def match(self, image): """Get a list of coordinates matching the morphological operation on an image Returns a list of tuples of (x,y) coordinates of all matching pixels.""" if self.lut is None: raise Exception('No operator loaded') return _imagingmorph.match(str(self.lut), image.im.id) def get_on_pixels(self, image): """Get a list of all turned on pixels in a binary image Returns a list of tuples of (x,y) coordinates of all matching pixels.""" return _imagingmorph.get_on_pixels(image.im.id) def load_lut(self, filename): """Load an operator from an mrl file""" with open(filename,'rb') as f: self.lut = bytearray(f.read()) if len(self.lut)!= 8192: self.lut = None raise Exception('Wrong size operator file!') def save_lut(self, filename): """Load an operator save mrl file""" if self.lut is None: raise Exception('No operator loaded') with open(filename,'wb') as f: f.write(self.lut) def set_lut(self, lut): """Set the lut from an external source""" self.lut = lut