154 lines
5.6 KiB
Python
154 lines
5.6 KiB
Python
import ch.psi.pshell.imaging.ImageBuffer as ImageBuffer
|
|
|
|
offset = 0
|
|
add_mark = False
|
|
#offset = 50
|
|
#add_mark = True
|
|
|
|
Image_Correlator = Context.getClassByName("Image_Correlator")
|
|
correlator = Image_Correlator()
|
|
|
|
def get_min(ip1):
|
|
return ip1.getProcessor().getStatistics().min
|
|
|
|
def mean_abs_error(ip1, ip2):
|
|
sum = 0.0
|
|
for y in range(ip1.getHeight()):
|
|
for x in range(ip1.getWidth()):
|
|
p1 = ip1.getPixel(x, y)
|
|
p2 = ip2.getPixel(x, y)
|
|
sum += abs(p1 - p2)
|
|
return sum / (ip1.height * ip1.width )
|
|
|
|
def rms_error(ip1, ip2):
|
|
sum = 0.0
|
|
for y in range(ip1.getHeight()):
|
|
for x in range(ip1.getWidth()):
|
|
p1 = ip1.getPixel(x, y)
|
|
p2 = ip2.getPixel(x, y)
|
|
sum += math.pow((p1 - p2),2)
|
|
return sum / (ip1.height * ip1.width )
|
|
|
|
|
|
|
|
def clear_dc(img, width=2):
|
|
img = load_image(img.getBufferedImage())
|
|
ip=img.getProcessor()
|
|
w, h = ip.getWidth(), ip.getHeight()
|
|
mask = ip.createProcessor(w, h) # Creates a new blank ImageProcessor
|
|
mask.setColor(255) # Set the drawing color to white (255)
|
|
o=width/2
|
|
mask.fillRect(0, 0,(w/2)-o,(h/2)-o)
|
|
mask.fillRect(0, int(h/2)+o,(w/2)-o,(h/2)-o)
|
|
mask.fillRect(int(w/2)+o,0,(w/2)-o,(h/2)-o)
|
|
mask.fillRect(int(w/2)+o, int(h/2)+o,(w/2)-o,(h/2)-o)
|
|
mask.autoThreshold() # Ensures the mask is binary (if needed)
|
|
ip.copyBits(mask, 0, 0, Blitter.AND) # Apply the mask using a bitwise AND
|
|
return img
|
|
|
|
|
|
|
|
|
|
def _get_roi_img(img, img_size=1024, radius=800, offset_x=0, offset_y=0):
|
|
x,y,w,h = int(cover_detection.config.center_x-img_size/2 + offset_x), \
|
|
int(cover_detection.config.center_y-img_size/2 + offset_y), \
|
|
img_size, img_size
|
|
roi = ImagingUtils.copy(img, None, Rectangle(x,y,w,h))
|
|
ip = load_image(roi, title="Img")
|
|
p = ip.getProcessor()
|
|
mask = p.createProcessor(roi.getWidth(), roi.getHeight())
|
|
mask.setColor(255)
|
|
cx, cy = img_size/2 - offset_x, img_size/2 - offset_y
|
|
mask.fillOval(int(cx - radius), int(cy - radius), int(2 * radius), int(2 * radius)) # Draw the circular ROI
|
|
mask.autoThreshold() # Ensures the mask is binary (if needed)
|
|
p.copyBits(mask, 0, 0, Blitter.AND) # Apply the mask using a bitwise AND
|
|
#gaussian_blur(ip)
|
|
p.blurGaussian(1.0)
|
|
return ip.getBufferedImage()
|
|
|
|
def get_roi_img(img, offset_x=0, offset_y=0):
|
|
img = ImagingUtils.copy(img, None, None)
|
|
center = cover_detection.config.center_x, cover_detection.config.center_y
|
|
#radius = cover_detection.config.diameter_dewar*(cover_detection.config.size_mask_dewar/2.0)
|
|
radius = cover_detection.config.diameter_dewar*0.45
|
|
ip = load_image(img, title="Img")
|
|
p = ip.getProcessor()
|
|
set_circle_mask(p, center_x=center[0], center_y=center[1],radius=radius)
|
|
p.translate(offset_x, offset_y)
|
|
return ip.getBufferedImage()
|
|
|
|
def get_edge_img(ib):
|
|
ed = ImagingUtils.edgeDetect(ib)
|
|
ret = load_image(ed, title="Refe")
|
|
#auto_threshold(ret, dark_background=True)
|
|
#binary_dilate(ret, iterations=1, count=1)
|
|
return ret
|
|
|
|
def save_ref_img(img):
|
|
global ip_ref_fe
|
|
path = os.path.abspath(expand_path("{images}/Correlation/ip_ref.png"))
|
|
roi=get_roi_img(img, offset_x=0, offset_y=0)
|
|
ImageBuffer.saveImage(roi, path, "png")
|
|
|
|
path = os.path.abspath(expand_path("{images}/Correlation/ip_ref_f.png"))
|
|
ip_ref_f = image_fft(load_image(roi))
|
|
ImageBuffer.saveImage(ip_ref_f.getBufferedImage(), path, "png")
|
|
|
|
path = os.path.abspath(expand_path("{images}/Correlation/ip_ref_e.png"))
|
|
ip_ref_e = get_edge_img(roi)
|
|
ImageBuffer.saveImage(ip_ref_e.getBufferedImage(), path, "png")
|
|
|
|
path = os.path.abspath(expand_path("{images}/Correlation/ip_ref_fe.png"))
|
|
ip_ref_fe = image_fft(ip_ref_e)
|
|
ImageBuffer.saveImage(ip_ref_fe.getBufferedImage(), path, "png")
|
|
|
|
#ip_ref = load_image(roi, title="ip_ref")
|
|
#save_image(ip_ref, path ,"png")
|
|
#$ImagingUtils.
|
|
#ip_ref_e =get_edge_img(roi)
|
|
#save_image(ip_ref_e, path+"ip_ref_e.png" ,"png")
|
|
##ip_ref_f = image_fft(ip_ref)
|
|
#ip_ref_fe = image_fft(ip_ref_e)
|
|
#save_image(ip_ref_fe, path+"ip_ref_fe.png" ,"png")
|
|
|
|
|
|
def put_mark(ib):
|
|
for x in range(700,750):
|
|
for y in range(650, 700):
|
|
ib.setRGB(x,y, 0)
|
|
|
|
def get_correlation(image=None):
|
|
if image is None:
|
|
image = img.output
|
|
global ip_ref_fe
|
|
if "ip_ref_fe" not in globals() or ip_ref_fe is None:
|
|
path = os.path.abspath(expand_path("{images}/Correlation/ip_ref.png"))
|
|
roi = ImagingUtils.newImage(path)
|
|
#ip_ref_fe=open_imagroie(path+"ip_ref_fe.png" ,"png")
|
|
#ip_ref = load_image(roi, title="ip_ref")
|
|
ip_ref_e =get_edge_img(roi)
|
|
ip_ref_fe = image_fft(ip_ref_e)
|
|
#ip_ref_fe = clear_dc(ip_ref_fe)
|
|
print "Opened reference image"
|
|
|
|
roi =get_roi_img(image, offset_x=-offset, offset_y=-offset)
|
|
if add_mark:
|
|
put_mark(roi)
|
|
#ip_cur = load_image(roi, title="Ref")
|
|
ip_cur_e =get_edge_img(roi)
|
|
#ip_cur_f = image_fft(ip_cur)
|
|
ip_cur_fe = image_fft(ip_cur_e)
|
|
#ip_cur_fe = clear_dc(ip_cur_fe)
|
|
return max(correlator.getCorrelation(ip_ref_fe, ip_cur_fe)[0], 0.0)
|
|
|
|
|
|
class CorrFilter(Filter):
|
|
def process(self, image, data):
|
|
roi=get_roi_img(image, offset_x=0, offset_y=0)
|
|
#ip_ref_f = image_fft(load_image(roi))
|
|
ip_ref_e = get_edge_img(roi)
|
|
ip_ref_fe = image_fft(ip_ref_e)
|
|
return ip_ref_fe.getBufferedImage()
|
|
|
|
|
|
corr_filter = CorrFilter() |