def getOverlapPercent(image1, image2, data):
#SET IMAGE LIMITS
gap = int(image1.shape[0] / 256.0)
xm = image1.shape[1] + gap
ym = image1.shape[0] + gap
a1 = numpy.array([
data['point1'],
[-gap, -gap],
[-gap, ym],
[xm, ym],
[xm, -gap],
])
xm = image2.shape[1] + gap
ym = image2.shape[0] + gap
a2 = numpy.array([
data['point2'],
[-gap, -gap],
[-gap, ym],
[xm, ym],
[xm, -gap],
])
#CALCULATE TRANSFORM LIMITS
a2mask = a1Toa2Data(a1, data)
a1mask = a2Toa1Data(a2, data)
#CONVERT NUMPY TO POLYGON LIST
a1masklist = []
a2masklist = []
for j in range(4):
for i in range(2):
item = int(a1mask[j + 1, i])
a1masklist.append(item)
item = int(a2mask[j + 1, i])
a2masklist.append(item)
#CREATE POLYGON MASK FROM THE LIMITS 1 -> IMAGE 2
mask2 = numpy.zeros(shape=image2.shape, dtype=numpy.bool_)
mask2b = apImage.arrayToImage(mask2, normalize=False)
mask2b = mask2b.convert("L")
draw2 = ImageDraw.Draw(mask2b)
draw2.polygon(a2masklist, fill="white")
mask2 = apImage.imageToArray(mask2b, dtype=numpy.float32)
#CREATE POLYGON MASK FROM THE LIMITS 2 -> IMAGE 1
mask1 = numpy.zeros(shape=image1.shape, dtype=numpy.bool_)
mask1b = apImage.arrayToImage(mask1, normalize=False)
mask1b = mask1b.convert("L")
draw1 = ImageDraw.Draw(mask1b)
draw1.polygon(a1masklist, fill="white")
mask1 = apImage.imageToArray(mask1b, dtype=numpy.float32)
percent1 = ndimage.sum(mask1) / (mask1.shape[0] *
mask1.shape[1]) / ndimage.maximum(mask1)
percent2 = ndimage.sum(mask2) / (mask2.shape[0] *
mask2.shape[1]) / ndimage.maximum(mask2)
return max(percent1, percent2), min(percent1, percent2)
def getOverlapPercent(image1, image2, data):
#SET IMAGE LIMITS
gap = int(image1.shape[0]/256.0)
xm = image1.shape[1]+gap
ym = image1.shape[0]+gap
a1 = numpy.array([ data['point1'], [-gap,-gap], [-gap,ym], [xm,ym], [xm,-gap], ])
xm = image2.shape[1]+gap
ym = image2.shape[0]+gap
a2 = numpy.array([ data['point2'], [-gap,-gap], [-gap,ym], [xm,ym], [xm,-gap], ])
#CALCULATE TRANSFORM LIMITS
a2mask = a1Toa2Data(a1, data)
a1mask = a2Toa1Data(a2, data)
#CONVERT NUMPY TO POLYGON LIST
a1masklist = []
a2masklist = []
for j in range(4):
for i in range(2):
item = int(a1mask[j+1,i])
a1masklist.append(item)
item = int(a2mask[j+1,i])
a2masklist.append(item)
#CREATE POLYGON MASK FROM THE LIMITS 1 -> IMAGE 2
mask2 = numpy.zeros(shape=image2.shape, dtype=numpy.bool_)
mask2b = apImage.arrayToImage(mask2, normalize=False)
mask2b = mask2b.convert("L")
draw2 = ImageDraw.Draw(mask2b)
draw2.polygon(a2masklist, fill="white")
mask2 = apImage.imageToArray(mask2b, dtype=numpy.float32)
#CREATE POLYGON MASK FROM THE LIMITS 2 -> IMAGE 1
mask1 = numpy.zeros(shape=image1.shape, dtype=numpy.bool_)
mask1b = apImage.arrayToImage(mask1, normalize=False)
mask1b = mask1b.convert("L")
draw1 = ImageDraw.Draw(mask1b)
draw1.polygon(a1masklist, fill="white")
mask1 = apImage.imageToArray(mask1b, dtype=numpy.float32)
percent1 = ndimage.sum(mask1) / (mask1.shape[0]*mask1.shape[1]) / ndimage.maximum(mask1)
percent2 = ndimage.sum(mask2) / (mask2.shape[0]*mask2.shape[1]) / ndimage.maximum(mask2)
return max(percent1,percent2), min(percent1,percent2)
def createTiltedPeakJpeg(imgdata1, imgdata2, peaktree1, peaktree2, params, procimg1=None, procimg2=None):
if 'templatelist' in params:
count = len(params['templatelist'])
else: count = 1
bin = int(params["bin"])
diam = float(params["diam"])
apix = float(params["apix"])
binpixrad = diam/apix/2.0/float(bin)
imgname1 = imgdata1['filename']
imgname2 = imgdata2['filename']
jpegdir = os.path.join(params['rundir'],"jpgs")
apParam.createDirectory(jpegdir, warning=False)
if procimg1 is not None:
imgarray1 = procimg1
else:
imgarray1 = apImage.preProcessImage(imgdata1['image'], bin=bin, planeReg=False, params=params)
if procimg2 is not None:
imgarray2 = procimg2
else:
imgarray2 = apImage.preProcessImage(imgdata2['image'], bin=bin, planeReg=False, params=params)
imgarray = numpy.hstack((imgarray1,imgarray2))
image = apImage.arrayToImage(imgarray)
image = image.convert("RGB")
image2 = image.copy()
draw = ImageDraw.Draw(image2)
#import pprint
if len(peaktree1) > 0:
#pprint.pprint(peaktree1)
drawPeaks(peaktree1, draw, bin, binpixrad)
if len(peaktree2) > 0:
peaktree2adj = []
for peakdict in peaktree2:
peakdict2adj = {}
#pprint.pprint(peakdict)
peakdict2adj['xcoord'] = peakdict['xcoord'] + imgdata1['image'].shape[1]
peakdict2adj['ycoord'] = peakdict['ycoord']
peakdict2adj['peakarea'] = 1
peakdict2adj['tmplnum'] = 2
peaktree2adj.append(peakdict2adj.copy())
#pprint.pprint(peaktree2adj)
drawPeaks(peaktree2adj, draw, bin, binpixrad)
image = Image.blend(image, image2, 0.9)
outfile1 = os.path.join(jpegdir, imgname1+".prtl.jpg")
apDisplay.printMsg("writing peak JPEG: "+outfile1)
image.save(outfile1, "JPEG", quality=95)
outfile2 = os.path.join(jpegdir, imgname2+".prtl.jpg")
apDisplay.printMsg("writing peak JPEG: "+outfile2)
image.save(outfile2, "JPEG", quality=95)
return
def subCreatePeakJpeg(imgarray, peaktree, pixrad, imgfile, bin=1, msg=True):
image = apImage.arrayToImage(imgarray)
image = image.convert("RGB")
image2 = image.copy()
draw = ImageDraw.Draw(image2)
if len(peaktree) > 0:
drawPeaks(peaktree, draw, bin, pixrad)
if msg is True:
apDisplay.printMsg("writing peak JPEG: "+imgfile)
image = Image.blend(image, image2, 0.9)
image.save(imgfile, "JPEG", quality=95)
def subCreatePeakJpeg(imgarray, peaktree, pixrad, imgfile, bin=1, msg=True):
image = apImage.arrayToImage(imgarray)
image = image.convert("RGB")
image2 = image.copy()
draw = ImageDraw.Draw(image2)
if len(peaktree) > 0:
drawPeaks(peaktree, draw, bin, pixrad)
if msg is True:
apDisplay.printMsg("writing peak JPEG: " + imgfile)
image = Image.blend(image, image2, 0.9)
image.save(imgfile, "JPEG", quality=95)
def createTiltedPeakJpeg(imgdata1, imgdata2, peaktree1, peaktree2, params, procimg1=None, procimg2=None):
if 'templatelist' in params:
count = len(params['templatelist'])
else: count = 1
bin = int(params["bin"])
diam = float(params["diam"])
apix = float(params["apix"])
binpixrad = diam/apix/2.0/float(bin)
imgname1 = imgdata1['filename']
imgname2 = imgdata2['filename']
jpegdir = os.path.join(params['rundir'],"jpgs")
apParam.createDirectory(jpegdir, warning=False)
if procimg1 is not None:
imgarray1 = procimg1
else:
imgarray1 = apImage.preProcessImage(imgdata1['image'], bin=bin, planeReg=False, params=params)
if procimg2 is not None:
imgarray2 = procimg2
else:
imgarray2 = apImage.preProcessImage(imgdata2['image'], bin=bin, planeReg=False, params=params)
imgarray = numpy.hstack((imgarray1,imgarray2))
image = apImage.arrayToImage(imgarray)
image = image.convert("RGB")
image2 = image.copy()
draw = ImageDraw.Draw(image2)
#import pprint
if len(peaktree1) > 0:
#pprint.pprint(peaktree1)
drawPeaks(peaktree1, draw, bin, binpixrad)
if len(peaktree2) > 0:
peaktree2adj = []
for peakdict in peaktree2:
peakdict2adj = {}
#pprint.pprint(peakdict)
peakdict2adj['xcoord'] = peakdict['xcoord'] + imgdata1['image'].shape[1]
peakdict2adj['ycoord'] = peakdict['ycoord']
peakdict2adj['peakarea'] = 1
peakdict2adj['tmplnum'] = 2
peaktree2adj.append(peakdict2adj.copy())
#pprint.pprint(peaktree2adj)
drawPeaks(peaktree2adj, draw, bin, binpixrad)
image = Image.blend(image, image2, 0.9)
outfile1 = os.path.join(jpegdir, imgname1+".prtl.jpg")
apDisplay.printMsg("writing peak JPEG: "+outfile1)
image.save(outfile1, "JPEG", quality=95)
outfile2 = os.path.join(jpegdir, imgname2+".prtl.jpg")
apDisplay.printMsg("writing peak JPEG: "+outfile2)
image.save(outfile2, "JPEG", quality=95)
return
def createPeakMapImage(peaktree,
ccmap,
imgname="peakmap.jpg",
pixrad="10.0",
bin=1.0,
msg=True):
### drop all values below zero
ccmap = numpy.where(ccmap < 0, 0.0, ccmap)
### create bar at bottom
ccshape = (ccmap.shape[0] + 50, ccmap.shape[1])
bigmap = numpy.resize(ccmap, ccshape)
bigmap[ccshape[0] + 1:, :] = 0
minval = ccmap.min()
maxval = ccmap.max()
#print minval,maxval
grad = numpy.linspace(minval, maxval, bigmap.shape[1])
bigmap[ccmap.shape[0]:bigmap.shape[0], :] = grad
#print ccmap.shape, "-->", bigmap.shape
image = apImage.arrayToImage(bigmap, stdevLimit=8.0)
image = image.convert("RGB")
### color stuff below threshold
#threshmap = imagefun.threshold(ccmap, threshold)
#filtmap = numpy.where(threshmap > 0, -3.0, ccmap)
#imagefilt = apImage.arrayToImage(filtmap)
#imagefilt = imagefilt.convert("RGB")
#imagefilt = ImageOps.colorize(imagefilt, "black", "green")
#image = Image.blend(image, imagefilt, 0.2)
### color peaks in map
image2 = image.copy()
peakdraw = ImageDraw.Draw(image2)
drawPeaks(peaktree, peakdraw, bin, pixrad, fill=True)
### add text
image3 = image.copy()
textdraw = ImageDraw.Draw(image3)
addMinMaxTextToMap(textdraw, bigmap.shape[1], minval, maxval)
### merge
image = Image.blend(image, image3, 0.9)
image = Image.blend(image, image2, 0.2)
if msg is True:
apDisplay.printMsg("writing summary JPEG: " + imgname)
image.save(imgname, "JPEG", quality=80)
def createPeakMapImage(peaktree, ccmap, imgname="peakmap.jpg", pixrad="10.0", bin=1.0, msg=True):
### drop all values below zero
ccmap = numpy.where(ccmap<0, 0.0, ccmap)
### create bar at bottom
ccshape = (ccmap.shape[0]+50, ccmap.shape[1])
bigmap = numpy.resize(ccmap, ccshape)
bigmap[ccshape[0]+1:,:] = 0
minval = ccmap.min()
maxval = ccmap.max()
#print minval,maxval
grad = numpy.linspace(minval, maxval, bigmap.shape[1])
bigmap[ccmap.shape[0]:bigmap.shape[0],:] = grad
#print ccmap.shape, "-->", bigmap.shape
image = apImage.arrayToImage(bigmap, stdevLimit=8.0)
image = image.convert("RGB")
### color stuff below threshold
#threshmap = imagefun.threshold(ccmap, threshold)
#filtmap = numpy.where(threshmap > 0, -3.0, ccmap)
#imagefilt = apImage.arrayToImage(filtmap)
#imagefilt = imagefilt.convert("RGB")
#imagefilt = ImageOps.colorize(imagefilt, "black", "green")
#image = Image.blend(image, imagefilt, 0.2)
### color peaks in map
image2 = image.copy()
peakdraw = ImageDraw.Draw(image2)
drawPeaks(peaktree, peakdraw, bin, pixrad, fill=True)
### add text
image3 = image.copy()
textdraw = ImageDraw.Draw(image3)
addMinMaxTextToMap(textdraw, bigmap.shape[1], minval, maxval)
### merge
image = Image.blend(image, image3, 0.9)
image = Image.blend(image, image2, 0.2)
if msg is True:
apDisplay.printMsg("writing summary JPEG: "+imgname)
image.save(imgname, "JPEG", quality=80)
def maskOverlapRegion(image1, image2, data):
#image1 = ndimage.median_filter(image1, size=2)
#image2 = ndimage.median_filter(image2, size=2)
#SET IMAGE LIMITS
####################################
gap = int(image1.shape[0] / 256.0)
xm = image1.shape[1] + gap
ym = image1.shape[0] + gap
a1 = numpy.array([
data['point1'],
[-gap, -gap],
[-gap, ym],
[xm, ym],
[xm, -gap],
])
xm = image2.shape[1] + gap
ym = image2.shape[0] + gap
a2 = numpy.array([
data['point2'],
[-gap, -gap],
[-gap, ym],
[xm, ym],
[xm, -gap],
])
#CALCULATE TRANSFORM LIMITS
####################################
a2mask = a1Toa2Data(a1, data)
a1mask = a2Toa1Data(a2, data)
#print "a1=",a1
#print "a1mask=",a1mask
#print "a2=",a2
#print "a2mask=",a2mask
#CONVERT NUMPY TO POLYGON LIST
####################################
#maskimg2 = polygon.filledPolygon(img.shape, vert2)
a1masklist = []
a2masklist = []
for j in range(4):
for i in range(2):
item = int(a1mask[j + 1, i])
a1masklist.append(item)
item = int(a2mask[j + 1, i])
a2masklist.append(item)
#CREATE POLYGON MASK FROM THE LIMITS 1 -> IMAGE 2
####################################
#print "a2mask=",numpy.asarray(a2mask, dtype=numpy.int32)
#print "a2masklist=",a2masklist
mask2 = numpy.zeros(shape=image2.shape, dtype=numpy.bool_)
mask2b = apImage.arrayToImage(mask2, normalize=False)
mask2b = mask2b.convert("L")
draw2 = ImageDraw.Draw(mask2b)
draw2.polygon(a2masklist, fill="white")
mask2 = apImage.imageToArray(mask2b, dtype=numpy.float32)
#DRAW POLYGON ONTO IMAGE 2
####################################
mean2 = ndimage.mean(image2)
std2 = ndimage.standard_deviation(image2)
immin2 = mean2 - 2.0 * std2
#med2 = numpy.median(image2.flatten())
#print "MAX=",ndimage.maximum(image2), med2, mean2, std2
#immin2 = ndimage.minimum(image2)+1.0
image2 = (image2 - immin2) * mask2 / 255.0
#mean2 = ndimage.mean(image2)
#std2 = ndimage.standard_deviation(image2)
#med2 = numpy.median(image2.flatten())
immax2 = min(ndimage.maximum(image2), 8.0 * std2)
#print "MAX=",ndimage.maximum(image2), med2, mean2, std2
#immax2 = mean2 + 3.0 * std2
image2 = numpy.where(image2 == 0, immax2, image2)
#CREATE POLYGON MASK FROM THE LIMITS 2 -> IMAGE 1
####################################
#print "a1mask=",numpy.asarray(a1mask, dtype=numpy.int32)
#print "a1masklist=",a1masklist
mask1 = numpy.zeros(shape=image1.shape, dtype=numpy.bool_)
mask1b = apImage.arrayToImage(mask1, normalize=False)
mask1b = mask1b.convert("L")
draw1 = ImageDraw.Draw(mask1b)
draw1.polygon(a1masklist, fill="white")
mask1 = apImage.imageToArray(mask1b, dtype=numpy.float32)
#DRAW POLYGON ONTO IMAGE 1
####################################
mean1 = ndimage.mean(image1)
std1 = ndimage.standard_deviation(image1)
#med1 = numpy.median(image1.flatten())
immin1 = mean1 - 2.0 * std1
#immin1 = ndimage.minimum(image1)+1.0
#print "MAX=",ndimage.maximum(image1), med1, mean1, std1
image1 = (image1 - immin1) * mask1 / 255.0
#mean1 = ndimage.mean(image1)
#std1 = ndimage.standard_deviation(image1)
#med1 = numpy.median(image1.flatten())
immax1 = min(ndimage.maximum(image1), 8.0 * std1)
#print "MAX=",ndimage.maximum(image1), med1, mean1, std1
#immax1 = mean1 + 3.0 * std1
image1 = numpy.where(image1 == 0, immax1, image1)
return (image1, image2)
def maskOverlapRegion(image1, image2, data):
#image1 = ndimage.median_filter(image1, size=2)
#image2 = ndimage.median_filter(image2, size=2)
#SET IMAGE LIMITS
####################################
gap = int(image1.shape[0]/256.0)
xm = image1.shape[1]+gap
ym = image1.shape[0]+gap
a1 = numpy.array([ data['point1'], [-gap,-gap], [-gap,ym], [xm,ym], [xm,-gap], ])
xm = image2.shape[1]+gap
ym = image2.shape[0]+gap
a2 = numpy.array([ data['point2'], [-gap,-gap], [-gap,ym], [xm,ym], [xm,-gap], ])
#CALCULATE TRANSFORM LIMITS
####################################
a2mask = a1Toa2Data(a1, data)
a1mask = a2Toa1Data(a2, data)
#print "a1=",a1
#print "a1mask=",a1mask
#print "a2=",a2
#print "a2mask=",a2mask
#CONVERT NUMPY TO POLYGON LIST
####################################
#maskimg2 = polygon.filledPolygon(img.shape, vert2)
a1masklist = []
a2masklist = []
for j in range(4):
for i in range(2):
item = int(a1mask[j+1,i])
a1masklist.append(item)
item = int(a2mask[j+1,i])
a2masklist.append(item)
#CREATE POLYGON MASK FROM THE LIMITS 1 -> IMAGE 2
####################################
#print "a2mask=",numpy.asarray(a2mask, dtype=numpy.int32)
#print "a2masklist=",a2masklist
mask2 = numpy.zeros(shape=image2.shape, dtype=numpy.bool_)
mask2b = apImage.arrayToImage(mask2, normalize=False)
mask2b = mask2b.convert("L")
draw2 = ImageDraw.Draw(mask2b)
draw2.polygon(a2masklist, fill="white")
mask2 = apImage.imageToArray(mask2b, dtype=numpy.float32)
#DRAW POLYGON ONTO IMAGE 2
####################################
mean2 = ndimage.mean(image2)
std2 = ndimage.standard_deviation(image2)
immin2 = mean2 - 2.0*std2
#med2 = numpy.median(image2.flatten())
#print "MAX=",ndimage.maximum(image2), med2, mean2, std2
#immin2 = ndimage.minimum(image2)+1.0
image2 = (image2-immin2)*mask2/255.0
#mean2 = ndimage.mean(image2)
#std2 = ndimage.standard_deviation(image2)
#med2 = numpy.median(image2.flatten())
immax2 = min(ndimage.maximum(image2), 8.0*std2)
#print "MAX=",ndimage.maximum(image2), med2, mean2, std2
#immax2 = mean2 + 3.0 * std2
image2 = numpy.where(image2==0, immax2, image2)
#CREATE POLYGON MASK FROM THE LIMITS 2 -> IMAGE 1
####################################
#print "a1mask=",numpy.asarray(a1mask, dtype=numpy.int32)
#print "a1masklist=",a1masklist
mask1 = numpy.zeros(shape=image1.shape, dtype=numpy.bool_)
mask1b = apImage.arrayToImage(mask1, normalize=False)
mask1b = mask1b.convert("L")
draw1 = ImageDraw.Draw(mask1b)
draw1.polygon(a1masklist, fill="white")
mask1 = apImage.imageToArray(mask1b, dtype=numpy.float32)
#DRAW POLYGON ONTO IMAGE 1
####################################
mean1 = ndimage.mean(image1)
std1 = ndimage.standard_deviation(image1)
#med1 = numpy.median(image1.flatten())
immin1 = mean1 - 2.0 * std1
#immin1 = ndimage.minimum(image1)+1.0
#print "MAX=",ndimage.maximum(image1), med1, mean1, std1
image1 = (image1-immin1)*mask1/255.0
#mean1 = ndimage.mean(image1)
#std1 = ndimage.standard_deviation(image1)
#med1 = numpy.median(image1.flatten())
immax1 = min(ndimage.maximum(image1), 8.0*std1)
#print "MAX=",ndimage.maximum(image1), med1, mean1, std1
#immax1 = mean1 + 3.0 * std1
image1 = numpy.where(image1==0, immax1, image1)
return (image1, image2)
