def main():
print 'executing...'
im = util.open('in/image1.png')
openingFile = "out/opening-" + datetime.now().strftime('%Y%m%d%H%M%S') + ".png"
arr = util.toBytes(im)
start = time.time()
arr = grayScale.averaging(arr)
print 'grayscale : ' + str(time.time() - start)
start = time.time()
arr = smoothening.median(arr, im.width, im.height, 2)
print 'median : ' + str(time.time() - start)
start = time.time()
arr = util.uniformedThresholding(arr, im.width, im.height, (125, 125, 125))
print 'uniformedThresholding : ' + str(time.time() - start)
start = time.time()
window = [(0, 0, 0)] * 3 * 3
opened = opening(arr, im.width, im.height, window, 3, 3, window, 3, 3)
print 'opening : ' + str(time.time() - start)
util.save(openingFile, opened, im.mode, im.size)
print 'done executing...'
def saveChunks(inputDir, outputDir, relevanceThreshold=255):
print "saveChunks from %s to %s " % (inputDir, outputDir)
imageIndex = 1
for fileName in os.listdir(inputDir):
path = inputDir + '/' + fileName
f, file_extension = os.path.splitext(path)
if file_extension == '.png':
maskImage = ImageUtils.preprocessMask(Image.open(path),210)
chunks = ImageUtils.splitImageInChunks(maskImage, chunkWidth, chunkHeight)
for index, c in enumerate(chunks):
if(chunkIsRelevant(c)):
c.save("%s/chunk-%s-%s-%s%s" % (outputDir, imageIndex, int(index % 20), int(index / 20), file_extension))
imageIndex+=1
continue
if not isfile(path) or file_extension != '.jpg':
continue
print "- opening "+path
srcImage = ImageUtils.preprocessImage(Image.open(path), 240)
if file_extension == '.jpg':
chunks = ImageUtils.splitImageInChunks(srcImage, chunkWidth, chunkHeight)
for index, c in enumerate(chunks):
savePath = "%s/chunk-%s-%s-%s%s" % (outputDir, imageIndex, int(index % 20), int(index / 20), file_extension)
if(chunkIsRelevant(c, relevanceThreshold)):
c.save(savePath, quality=95)
print "savechunks - finished"
def transform(self):
self.target = self.component.transform()
hessian = Hessian()
img_max_eigenvalues, img_min_eigenvalues = hessian.calculate(
self.target, self.scale)
utils = ImageUtils()
return utils.max(img_max_eigenvalues, img_min_eigenvalues)
def print_remove(image_path):
src = teacher_remove(image_path)
image = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
ret1, th1 = cv2.threshold(image, 200, 255, cv2.THRESH_BINARY)
ImageUtils.show_images([image, th1], 1)
def main():
print 'executing...'
im = util.open('in/image1.png')
openingFile = "out/opening-" + datetime.now().strftime(
'%Y%m%d%H%M%S') + ".png"
arr = util.toBytes(im)
start = time.time()
arr = grayScale.averaging(arr)
print 'grayscale : ' + str(time.time() - start)
start = time.time()
arr = smoothening.median(arr, im.width, im.height, 2)
print 'median : ' + str(time.time() - start)
start = time.time()
arr = util.uniformedThresholding(arr, im.width, im.height, (125, 125, 125))
print 'uniformedThresholding : ' + str(time.time() - start)
start = time.time()
window = [(0, 0, 0)] * 3 * 3
opened = opening(arr, im.width, im.height, window, 3, 3, window, 3, 3)
print 'opening : ' + str(time.time() - start)
util.save(openingFile, opened, im.mode, im.size)
print 'done executing...'
def getDuring(self):
print("getDuring")
timeInfo = ImageUtils.ocr(
ImageUtils.image_to_bytes(
ImageUtils.screenshotByImage("./boxue_img/play_player.png", 60,
0, 45, 26)))
during = timeUtils.t2s(timeInfo['words_result'][0]['words'])
print(during)
return during
def getDuring(self):
timeInfo = ImageUtils.ocr(
ImageUtils.image_to_bytes(
ImageUtils.screenshotByImage('./img/player_during.png', 0, 0,
150, 40)))
during = timeUtils.handleOcrTime(
timeInfo['words_result'][0]['words'].split('/'))
print(during)
return during
def getImageAndMaskDifferenceChunks(imgPath):
srcImage, maskImage = getImageAndMask(imgPath)
srcImage = ImageUtils.preprocessImage(srcImage,240)
maskImage = ImageUtils.preprocessMask(maskImage, 210)
imageChunks = ImageUtils.splitImageInChunks(srcImage, chunkWidth, chunkHeight)
maskChunks = ImageUtils.splitImageInChunks(maskImage, chunkWidth, chunkHeight)
return ImageUtils.getDifferenceChunks(imageChunks, maskChunks)
def main():
im = util.open('in/image1.png')
arr = util.toBytes(im)
out = []
fileMedian = "out/m-" + datetime.now().strftime('%Y%m%d%H%M%S') + ".png"
print("Executing... ")
start = time.time()
out = median(arr, im.width, im.height, 2)
print 'median : ' + str(time.time() - start)
util.save(fileMedian, out, im.mode, im.size)
print("done saving ")
def ComputeMeanStd(self,img):
gray = np.zeros((3,3),dtype=np.uint8)
if ImageUtils.IsGrayImage(img):
gray = img.copy()
gray = cv2.cvtColor(img,cv2.COLOR_RGB2GRAY)
else:
gray = ImageUtils.GrayImage(img)
th, binGray = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
blurBin = cv2.blur(binGray, (5,5))
meanPre, stddevPre = ImageUtils.GetMeanStd(gray, binGray, 'pre')
meanBack, stddevBack = ImageUtils.GetMeanStd(gray, binGray, 'back')
return meanPre, stddevPre, meanBack, stddevBack
def teacher_remove(image_path):
src = cv2.imread(image_path) # shape: (1080, 1863, 3)
image = src.copy()
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
# CLAHE (Contrast Limited Adaptive Histogram Equalization)
ImageUtils.clahe_hsv(hsv)
mask = ImageUtils.get_hsvmask(hsv, 160, 70, 70, 30)
mask = ImageUtils.erode_dilate(mask, 3)
result = ImageUtils.swap_color(image, mask, 255)
# ImageUtils.show_images([src, result], 1)
return result
def process_item(self, item, spider):
formate = item['cover'][item['cover'].rindex('.'):]
dirPath = 'cover/' + item['artist_name']
filePath = 'cover/' + item['artist_name'] + '/' + item['album_name'] + formate
if os.path.exists(filePath):
raise DropItem("Duplicate item found: %s" % item['album_name'])
else:
if not os.path.exists(dirPath):
os.makedirs(dirPath)
f = urllib2.urlopen(item['cover'])
with open(filePath, "wb") as code:
code.write(f.read())
f.close()
code.close()
info = ImageUtils.get_image_info(filePath)
item['cover_path'] = filePath
item['cover_color'] = info[0]
item['cover_width'] = info[1]
item['cover_height'] = info[2]
return item
def fft(self):
"""
Converts the color to l-values, then calculates the 2 dimensional
Fourier transform.
Displays the values shifted to the center of the image, on a
logarithmic scale.
"""
gray = ImageUtils.rgb2grey_fixed(self.image_array)
transformed = numpy.fft.fft2(gray)
fshift = numpy.fft.fftshift(transformed)
fshift = 20 * numpy.log(numpy.abs(fshift))
fshift += fshift.min()
fshift *= (255 / fshift.max())
pyplot.figure(1)
pyplot.subplot(121)
pyplot.imshow(gray, cmap="gray")
pyplot.title("Input image")
pyplot.subplot(122)
pyplot.imshow(fshift, cmap="Set1")
pyplot.title("Fourier transformation")
pyplot.show()
def handle_extract_face_features():
face = ImageUtils.decode_image_buffer(
bytearray(request.json['face']['data']))
aligned_face = RecogitionService.align_face(face)
face_features = RecogitionService.extract_features(aligned_face)
return jsonify({"model": list(face_features)})
def read_processed(self):
frame = None
with self.captureLock:
frame = self.processing_frame
frame = ImageUtils.resize_mjpeg(frame)
ret, jpeg = cv2.imencode('.jpg', frame)
return jpeg.tostring()
def sobel(self):
"""
Performs the sobel operator in x and y direction and combines the
output. The output is normalized by using contrast_stretch.
"""
gray = ImageUtils.rgb2grey_fixed(self.image_array) / 255
sobel_x = ndimage.sobel(gray, 0)
sobel_y = ndimage.sobel(gray, 1)
sobel_xy = numpy.hypot(sobel_x, sobel_y)
sobel_xy = ImageUtils.normalize_intensity_p298(sobel_xy)
# sobel_xy *= (255 / sobel_xy.max())
sobel_xy = ImageUtils.rgb2grey_fixed(sobel_xy)
self._update_image_data(sobel_xy, "Sobel edge-detection")
def trainOnImage(imageId, model, cbs, modelParams):
logging.info("Training on image: {0}".format(imageId))
(img, mask) = ImageUtils.loadImage(imageId)
(imgs, classes, masks) = genPatches(img, mask, modelParams)
(x_train, x_cv, y_train, y_cv) = scv.train_test_split(imgs,
masks,
test_size=0.2)
y_train_cat = np_utils.to_categorical(y_train.flatten(),
modelParams.nb_classes)
y_train_cat = y_train_cat.reshape(
(y_train.shape[0], y_train.shape[1] * y_train.shape[2],
modelParams.nb_classes))
model.fit(x_train,
y_train_cat,
nb_epoch=modelParams.epochs,
batch_size=modelParams.batchSize,
callbacks=cbs,
validation_split=0.2)
logging.info("Training completed, evaluating model")
y_cv_cat = np_utils.to_categorical(y_cv.flatten(), modelParams.nb_classes)
y_cv_cat = y_cv_cat.reshape(
(y_cv.shape[0], y_cv.shape[1] * y_cv.shape[2], modelParams.nb_classes))
loss = model.evaluate(x_cv, y_cv_cat, batch_size=modelParams.batchSize)
logging.info("Loss: {0}".format(str(loss)))
return model
def grayscale(self):
"""
Converts RGB values of the image to luminosity values, thus giving
the image a 'grayscale' effect.
"""
grey = ImageUtils.rgb2grey_fixed(self.image_array)
self._update_image_data(grey, "Grayscale")
def contrast_stretch(self):
"""
Rescales the intensity values of the image based on the 2 and 98
percentiles.
"""
normalized = ImageUtils.normalize_intensity_p298(self.image_array)
self._update_image_data(normalized, "Contrast stretch")
def TraverseLine(img, w, h, fromDirection, linePointThresold, directions, count, continuesDo = None):
def callContinus():
if continuesDo is None:
return True
newDirections = []
for direction in directions:
newDirections.append((-direction[0], -direction[1]))
return continuesDo(newDirections, count)
if w <= 1 or w >= img.width - 1:
return callContinus()
if h <= 1 or h >= img.height - 1:
return callContinus()
count += 1
c = img.getpixel((w, h))
similars = ImageUtils.getSimilarNeighbors(img, c, (w, h), [(0,0), fromDirection])
similarCount = len(similars)
if similarCount > 1:
if count >= linePointThresold:
if continuesDo is None:
img.putpixel((w, h), color.BLACK_COLOR)
return True
elif callContinus():
img.putpixel((w, h), color.BLACK_COLOR)
return True
return False
if 0 == similarCount:
if callContinus():
img.putpixel((w, h), color.BLACK_COLOR)
return True
return False
sw, sh = similars[0]
if 0 == len(directions):
directions = similars
elif 1 == len(directions):
dw, dh = directions[0]
distW, distH = (sw - dw, sh - dh)
dist = distW * distW + distH * distH
if 0 == dist:
pass
elif 1 == dist:
directions.append((sw, sh))
else:
return False
elif (sw, sh) in directions:
pass
else:
return False
if TraverseLine(img, w + sw, h + sh, (-sw, -sh), linePointThresold, directions, count, continuesDo):
img.putpixel((w, h), color.BLACK_COLOR)
return True
def feature():
req_parm = request.json
print type(req_parm)
import faceUtils
import ImageUtils
image_array = ImageUtils.base64_to_array(req_parm[u'hello'])
feature = faceUtils.face_feature(image_array)
# face_cuts = faceUtils.face_cut(image_array)
return json.dumps(feature, ensure_ascii=False)
def laplace(self, sigma=1):
"""
Performs the laplacian filter based on gaussian derivatives.
This allows for controlling the level of detail in the output image.
"""
gray = ImageUtils.rgb2grey_fixed(self.image_array)
laplace = ndimage.gaussian_laplace(gray, sigma)
self._update_image_data(laplace, "Laplace edge-detection")
def getSplitRatio(self, remove=True):
import ImageUtils as iu
lowestMagnification = self.magnifications[
-2] # Sometimes the lowest magnification image is truncated
imgPath = self.split(lowestMagnification, compression=COMPRESSION_NONE)
splitRatio = iu.getSplitLeftRightColumnRatio(imgPath)
if remove:
os.remove(imgPath)
return splitRatio
def getImageMask(img, model):
gall_t = ImageUtils.genPatches(img.shape[1:], (img_dim_y, img_dim_x), img_dim_x)
(imgs_t, classes_t, masks_t) = ImageUtils.prepareDataSets(gall_t, img, mask)
coords = [x for x in ImageUtils.genPatches(img.shape[1:], (img_dim_y, img_dim_x), img_dim_x)]
all_rez = model.predict(imgs_t, batch_size=4)
rez1 = np.array(all_rez)
rez1[:,:,0:1] *= 0.1
rez_img = np.argmax(rez1, axis = 2)
rez_img = rez_img.reshape((-1, img_dim_y, img_dim_x))
mask_rez = np.zeros(img.shape[1:])
for i in range(len(coords)):
(y, x, h, w) = coords[i]
mask_rez[y:(y+h), x:(x+h)] = rez_img[i]
return mask_rez
def clean(img, linePointThresold = 5):
for h in range(1, img.height - 1):
for w in range(1, img.width - 1):
c = img.getpixel((w, h))
if color.isBackground(c):
img.putpixel((w, h), color.BLACK_COLOR)
else:
similars = ImageUtils.getSimilarNeighbors(img, c, (w, h), [(0,0)])
similarCount = len(similars)
if 0 == similarCount:
if len(ImageUtils.getBackgrondNeighbors(img, c, (w, h))) == 7:
img.putpixel((w, h), color.BLACK_COLOR)
continue
count = 1
if 1 == similarCount:
ww, hh = similars[0]
if TraverseLine(img, w + ww, h + hh, (-ww, -hh), linePointThresold, similars, count):
img.putpixel((w, h), color.BLACK_COLOR)
elif 2 == similarCount:
ww, hh = similars[0]
ww1, hh1 = similars[1]
if (ww * ww1 + hh * hh1) >= 0:
img.putpixel((w, h), color.BLACK_COLOR)
continue
if (1, 0) not in similars or (-1, 1) not in similars:
if hh1 > hh or (hh1 == hh and ww1 > ww):
tmpW = ww; tmpH = hh
ww = ww1; hh = hh1
ww1 = tmpW; hh1 = tmpH
if TraverseLine(img, w + ww, h + hh, (-ww, -hh), linePointThresold, similars, count):
img.putpixel((w, h), color.BLACK_COLOR)
img.putpixel((w + ww1, h + hh1), color.BLACK_COLOR)
continue
from functools import partial
continueDo = partial(TraverseLine, img, w + ww1, h + hh1, (-ww1, -hh1), linePointThresold)
if TraverseLine(img, w + ww, h + hh, (-ww, -hh), linePointThresold, [similars[0], (-ww1, -hh1)], count, continueDo):
img.putpixel((w, h), color.BLACK_COLOR)
def read_processed(self):
frame = None
with self.captureLock:
frame = self.processing_frame
while frame == None: # If there are problems, keep retrying until an image can be read.
with self.captureLock:
frame = self.processing_frame
frame = ImageUtils.resize_mjpeg(frame)
ret, jpeg = cv2.imencode('.jpg', frame)
return jpeg.tostring()
def read_jpg(self):
"""We are using Motion JPEG, and OpenCV captures raw images,
so we must encode it into JPEG in order to stream frames to
the client. It is nessacery to make the image smaller to
improve streaming performance"""
capture_blocker = self.captureEvent.wait()
frame = self.captureFrame
frame = ImageUtils.resize_mjpeg(frame)
ret, jpeg = cv2.imencode('.jpg', frame)
return jpeg.tostring()
def handle_recognize_face_from_features():
features = np.array(request.json['model'])
face_to_recognize = ImageUtils.decode_image_buffer(
bytearray(request.json['face']['data']))
aligned_face = RecogitionService.align_face(face_to_recognize)
face_to_recognize_features = RecogitionService.extract_features(
aligned_face)
are_same = RecogitionService.recognize(features,
face_to_recognize_features)
return jsonify({"areSame": are_same})
def __getitem__(self, index):
fg_index = index
bg_index = index % len(self.backgrounds)
# fetching foreground and background images
fg_img, label = self.foregrounds[fg_index]
bg_img, _ = self.backgrounds[bg_index]
# add alpha channel to foreground
fg_img = self.add_alpha(fg_img)
# random cropping background
bg_height = np.random.randint(bg_img.shape[0] // 2, bg_img.shape[0])
bg_width = np.random.randint(bg_img.shape[1] // 2, bg_img.shape[1])
x0 = self.safe_random(0, bg_img.shape[1] - bg_width)
y0 = self.safe_random(0, bg_img.shape[0] - bg_height)
bg_crop = bg_img[y0:y0 + bg_height, x0:x0 + bg_width]
bg_img = cv2.resize(bg_crop,
self.target_size,
interpolation=cv2.INTER_AREA)
# random squeezing foreground
fg_width = fg_img.shape[1]
fg_height = fg_img.shape[0]
random_w_squeeze = 1 - np.random.rand() * 0.2
random_h_squeeze = 1 - np.random.rand() * 0.2
tgt_fg_width = min(self.target_size[0],
int(fg_width * random_w_squeeze))
tgt_fg_height = min(self.target_size[1],
int(fg_height * random_h_squeeze))
fg_img = cv2.resize(fg_img, (tgt_fg_width, tgt_fg_height),
interpolation=cv2.INTER_AREA)
# augmentation of BG/FG
fg_img = self.augment(fg_img)
bg_img = self.augment(bg_img)
# alpha-blending
blended = self.blend(fg_img, bg_img)
# augmentation of composite
blended = self.augment_blended(blended)
rgb_tensor = ImageUtils.image_to_tensor(blended, unsqueeze=False)
# getting label index
label_index = self.foregrounds.labels.index(label)
label_tensor = torch.LongTensor([label_index])
return {'rgb': rgb_tensor, 'label': label_tensor}
def handleEdge(sortedWindow):
output = sortedWindow
idx = 0
resort = 0
while output[idx] == util.downSignal():
output[idx] = output[len(output) - 1 - idx]
idx = idx + 1
resort = 1
if resort == 1:
output = sorted(output, key=itemgetter(0, 1, 2))
return output
def test(image_path):
src = cv2.imread(image_path) # shape: (1080, 1863, 3)
image = src.copy()
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
#CLAHE (Contrast Limited Adaptive Histogram Equalization)
ImageUtils.clahe_hsv(hsv)
mask = ImageUtils.get_hsvmask(hsv, 170, 90, 64, 15)
mask = ImageUtils.erode_dilate(mask)
result = ImageUtils.swap_color(image, mask, 255)
ImageUtils.show_images([src, mask, result], 3)
def main():
print 'Executing Histograms.main'
im = util.open('in/captcha.png')
fileName = "out/normalized-" + datetime.now().strftime('%Y%m%d%H%M%S') + ".png"
fileName2 = "out/equalized-" + datetime.now().strftime('%Y%m%d%H%M%S') + ".png"
arr = util.toBytes(im)
arr = grayScale.averaging(arr)
util.save("out/tempGray.png", arr, im.mode, im.size)
# doesn't matter which color index bec. it's gray.
normalized = normalize(arr, im.width, im.height, 0)
equalized = equalize(arr, im.width, im.height, 0)
util.save(fileName, normalized, im.mode, im.size)
util.save(fileName2, equalized, im.mode, im.size)
print 'Done executing Histograms.main'
def main():
im = util.open('in/captcha.png')
arr = util.toBytes(im)
fileAverage = "out/a-" + datetime.now().strftime('%Y%m%d%H%M%S') + ".png"
fileLuminance = "out/l-" + datetime.now().strftime('%Y%m%d%H%M%S') + ".png"
fileLightness = "out/li-" + datetime.now().strftime('%Y%m%d%H%M%S') + ".png"
print("Executing... ")
averaged = averaging(arr)
luminous = luminousity(arr)
lightnessed = lightness(arr)
util.save(fileAverage, averaged, im.mode, im.size)
util.save(fileLuminance, luminous, im.mode, im.size)
util.save(fileLightness, lightnessed, im.mode, im.size)
print("done saving ")
def median2(input, w, h, ww, wh):
output = []
window = [util.downSignal()] * ww * wh
for row in range(h):
for col in range(w):
origin = row * w + col
for windowY in range(wh):
for windowX in range(ww):
y = row + windowY - (wh / 2)
x = col + windowX - (ww / 2)
# The following nested conditions makes sure that the
# kernel's origin doesn't go out of the image's boundaries.
if (x >= 0 and y >= 0):
if (x < w and y < h):
index = y * w + x
wIndex = windowY * ww + windowX
window[wIndex] = input[index]
window = sorted(window, key=itemgetter(0, 1, 2))
if (util.isEdge(origin, w, h)):
window = handleEdge(window)
output.append(window[len(window) / 2])
return output
def main():
im = util.open('in/captcha.png')
arr = util.toBytes(im)
fileAverage = "out/a-" + datetime.now().strftime('%Y%m%d%H%M%S') + ".png"
fileLuminance = "out/l-" + datetime.now().strftime('%Y%m%d%H%M%S') + ".png"
fileLightness = "out/li-" + datetime.now().strftime(
'%Y%m%d%H%M%S') + ".png"
print("Executing... ")
averaged = averaging(arr)
luminous = luminousity(arr)
lightnessed = lightness(arr)
util.save(fileAverage, averaged, im.mode, im.size)
util.save(fileLuminance, luminous, im.mode, im.size)
util.save(fileLightness, lightnessed, im.mode, im.size)
print("done saving ")
def activateOnImage(fnn, layerpath, saveWrongChunks=False, breakOnError=True, saveWrongImages=False):
try:
chunks = getImageAndMaskDifferenceChunks(layerpath)
except IOError as e:
print e
return
except ValueError as e:
print e
return
fileName = os.path.basename(layerpath)
index=1
needToSaveImage = False
for c in chunks:
cFlattened = np.asarray(c).flatten()
estimate = fnn.activate(cFlattened)
if estimate[0] < 0.7:
needToSaveImage = True
print "estimated error on %s. probability OK / KO: %s/%s" % (fileName, estimate[0], estimate[1])
if saveWrongChunks:
c.save(outputPath+"/chunk-%s.jpg" %(index))
if breakOnError:
break
index+=1
if needToSaveImage and saveWrongImages:
srcImage, maskImage = getImageAndMask(layerpath)
srcImage.save(outputPath+"/image-%s-original-image.jpg" %(index))
maskImage.save(outputPath+"/image-%s-original-mask.png" %(index))
srcImage = ImageUtils.preprocessImage(srcImage,240)
maskImage = ImageUtils.preprocessMask(maskImage, 210)
srcImage.save(outputPath+"/image-%s-elab-image.jpg" %(index))
maskImage.save(outputPath+"/image-%s-elab-mask.png" %(index))
return
def main():
print 'Executing Histograms.main'
im = util.open('in/captcha.png')
fileName = "out/normalized-" + datetime.now().strftime(
'%Y%m%d%H%M%S') + ".png"
fileName2 = "out/equalized-" + datetime.now().strftime(
'%Y%m%d%H%M%S') + ".png"
arr = util.toBytes(im)
arr = grayScale.averaging(arr)
util.save("out/tempGray.png", arr, im.mode, im.size)
# doesn't matter which color index bec. it's gray.
normalized = normalize(arr, im.width, im.height, 0)
equalized = equalize(arr, im.width, im.height, 0)
util.save(fileName, normalized, im.mode, im.size)
util.save(fileName2, equalized, im.mode, im.size)
print 'Done executing Histograms.main'
def SelectSameElementEx(origin, me, w, h, c, excludes, thresold = 0.5):
if w <= WMargin or w >= (origin.width - WMargin):
return 0
if h < HMargin or h >= (origin.height - HMargin):
return 0
if not hasattr(me, 'left'):
me.left = w
me.right = w
me.top = h
me.bottom = h
else:
if w < me.left:
me.left = w
elif w > me.right:
me.right = w
if h < me.top:
me.top = h
elif h > me.bottom:
me.bottom = h
count = 1
similars = ImageUtils.getSimilarNeighborsEx(origin, c, (w, h), excludes, thresold)
s1 = []
distMean = 0
for (ww, hh, dist) in similars:
cc = origin.getpixel((w + ww,h ++ hh))
if color.isBackground(cc):
continue
distMean += dist
cc = origin.getpixel((w + ww, h + hh))
s1.append((ww, hh, cc))
origin.putpixel((w + ww, h + hh), color.BLACK_COLOR)
me.putpixel((w + ww, h + hh), cc)
if 0 == len(s1):
return count
distMean /= len(s1)
thresold = thresold * SAME_ELEMENT_THRESOLD_ALPHA + (1 - SAME_ELEMENT_THRESOLD_ALPHA) * distMean
#print('%s thresold=%lf, distMean=%lf' % (FILEANME, thresold, distMean))
for (ww, hh, cc) in s1:
count += SelectSameElementEx(origin, me, w + ww, h + hh, cc, [(0, 0), (-ww, -hh)], thresold)
return count
def threshold(self, threshold, mode="binary"):
gray = ImageUtils.rgb2grey_fixed(self.image_array)
print(mode)
if mode == "binary":
for i in range(len(gray)):
gray[i] = [(0 if x < threshold else 255) for x in gray[i]]
elif mode == "binary_inverted":
for i in range(len(gray)):
gray[i] = [(255 if x < threshold else 0) for x in gray[i]]
elif mode == "drop_smaller_to_zero":
for i in range(len(gray)):
gray[i] = [(0 if x < threshold else x) for x in gray[i]]
elif mode == "raise_smaller_to_max":
for i in range(len(gray)):
gray[i] = [(255 if x < threshold else x) for x in gray[i]]
elif mode == "drop_bigger_to_zero":
for i in range(len(gray)):
gray[i] = [(0 if x > threshold else x) for x in gray[i]]
elif mode == "raise_bigger_to_max":
for i in range(len(gray)):
gray[i] = [(255 if x > threshold else x) for x in gray[i]]
elif mode == "clip_bigger":
for i in range(len(gray)):
gray[i] = [(threshold if x > threshold else x)
for x in gray[i]]
elif mode == "raise_smaller":
for i in range(len(gray)):
gray[i] = [(threshold if x < threshold else x)
for x in gray[i]]
self._update_image_data(gray, "Threshold")
def generateSamples(trainImages, modelParams):
while True:
# Choose an image
idx = np.random.randint(0, len(trainImages))
logging.info("Loading image: {0}".format(trainImages[idx]))
(img, mask) = ImageUtils.loadImage(trainImages[idx])
#img = cv2.GaussianBlur(img.reshape(img.shape[1:]), (5,5), 0).reshape(img.shape)
# Make patches
(imgs, classes, masks) = genPatches(img, mask, modelParams)
nSamples = imgs.shape[0]
idxs = np.random.permutation(np.arange(nSamples))[:modelParams.samples]
logging.info("Subsamples: {0}".format(idxs))
for i in range(modelParams.samples):
yield (imgs[idxs[i]], masks[idxs[i]])
def detectColor(color):
return ImageUtils.detectColor(image, color, 15, 75)
#extract peak frequencies smallcm = IU.Circularmask(autoc,s/2,3) pkfft = IU.PeakFilteredFFT(autoc,cxy,sigma=50) pkfft_abs = np.abs(pkfft)*smallcm #imshow_z(pkfft_abs) #get reci lattice vectors pos = IU.FindPeakPos(pkfft_abs) pos_zero = pos[:,3:5] - s/2 pos_zero = np.round(pos_zero,2) bs = VF.find_basis_set(pos_zero.T) r1,r2 = VF.get_reci_vecs2(bs[:,0],bs[:,1],1024) fig1 = imshow_z(filt2s,vmin=0,vmax=350) IU.draw_circles_along_vec(fig1,r1,[512,512],[1024,1024]) IU.draw_circles_along_vec(fig1,r2,[512,512],[1024,1024]) ########################################################################## #Extract peaks ########################################################################## #sort the peaks by strength and recenter some of them #thevecs1 = fill_space_with_basis2D(autoc,r1,r2,PY.array([512,512])) thevecs1 = VF.fill_space_with_basis2D_2(autoc,r1,r2,np.array([512,512])) #fig1 = imshow_z(filt2s,vmin=0,vmax=250) #IU.draw_circles_at_vec(fig1,thevecs1) #slightly shift the centroids and collec the intensities cents,sums = IU.DiffPeakSums(filt2s,thevecs1) fig1 = imshow_z(filt2s,vmin=0,vmax=250) IU.draw_circles_at_vec(fig1,thevecs1,color='w')
