def radon(image, stepsize=2, maskrad=None):
	from multiprocessing import Queue, Process
	t0 = time.time()
	### prepare mask
	if maskrad is None:
		maskrad = image.shape[0]/2
	blackcircle = imagefun.filled_circle(image.shape, maskrad)
	mask = 1 - blackcircle

	nsteps = int(math.ceil(180/stepsize))
	queuelist = []
	for row in range(nsteps):
		angle = -row*stepsize
		queue = Queue()
		queuelist.append(queue)
		#below is equivalent to "project(image, row, angle, mask, queue)"
		proc = Process(target=project, args=(image, row, angle, mask, queue))
		proc.start()
	proc.join()

	### assemble radon image
	radonimage = numpy.zeros( (nsteps, image.shape[0]) )
	for queue in queuelist:
		row, line = queue.get()
		radonimage[row, :] = line
		
	#radonlr = numpy.fliplr(radonimage)
	#radonimage = numpy.vstack((radonimage, radonlr))
	imagefile.arrayToJpeg(radonimage, "radonimage.jpg", msg=False)
	print "Multi radon completed in %s"%(apDisplay.timeString(time.time() - t0))
	return radonimage
def edgeNorm(imgarray):
	"""
	normalize an image with mean = 0 and stddev = 1.0
	in the outer ring of a particle
	"""
	edgeMask = imagefun.filled_circle(imgarray.shape)
	return normStdevMask(imgarray, edgeMask)
def radon(image, stepsize=2, maskrad=None):
    from multiprocessing import Queue, Process
    t0 = time.time()
    ### prepare mask
    if maskrad is None:
        maskrad = image.shape[0] / 2
    blackcircle = imagefun.filled_circle(image.shape, maskrad)
    mask = 1 - blackcircle

    nsteps = int(math.ceil(180 / stepsize))
    queuelist = []
    for row in range(nsteps):
        angle = -row * stepsize
        queue = Queue()
        queuelist.append(queue)
        #below is equivalent to "project(image, row, angle, mask, queue)"
        proc = Process(target=project, args=(image, row, angle, mask, queue))
        proc.start()
    proc.join()

    ### assemble radon image
    radonimage = numpy.zeros((nsteps, image.shape[0]))
    for queue in queuelist:
        row, line = queue.get()
        radonimage[row, :] = line

    #radonlr = numpy.fliplr(radonimage)
    #radonimage = numpy.vstack((radonimage, radonlr))
    imagefile.arrayToJpeg(radonimage, "radonimage.jpg", msg=False)
    print "Multi radon completed in %s" % (apDisplay.timeString(time.time() -
                                                                t0))
    return radonimage
	def preLoopFunctions(self):
		super(Makestack2Loop, self).preLoopFunctions()
		### create an edge map for edge statistics
		box = self.boxsize
		self.boxedpartdatas = None
		### use a radius one pixel less than the boxsize
		self.edgemap = imagefun.filled_circle((box, box), box/2.0-1.0)
		self.summedParticles = numpy.zeros((box, box))
def radonlist(imagelist, stepsize=2, maskrad=None, msg=None):
    """
	computes Radon transform of image list
	"""
    if msg is None and len(imagelist) > 50:
        msg = True
    elif msg is None:
        msg = False

    ### Note: multiprocessing version not compatible with python 2.4
    from multiprocessing import Queue, Process
    t0 = time.time()

    ### prepare mask
    shape = imagelist[0].shape
    if maskrad is None:
        maskrad = shape[0] / 2
    blackcircle = imagefun.filled_circle(shape, maskrad)
    mask = 1 - blackcircle

    ### preform radon transform for each image
    queuelist = []
    if msg is True:
        apDisplay.printMsg("Performing Radon transforms with multiprocessor")
    for imageid in range(len(imagelist)):
        if msg is True and imageid % 50 == 0:
            ### FUTURE: add time estimate
            sys.stderr.write(".")
        image = imagelist[imageid]
        queue = Queue()
        queuelist.append(queue)
        #below is equivalent to "radonImage(image, imageid, stepsize, mask, queue)"
        proc = Process(target=radonImage,
                       args=(image, imageid, stepsize, mask, queue))
        proc.start()
    proc.join()

    ### assemble radon image list
    radonimagelist = range(len(imagelist))
    for queue in queuelist:
        imageid, radonimage = queue.get()
        radonimagelist[imageid] = radonimage
    if msg is True:
        sys.stderr.write("\n")
        print "Multi Radon images complete in %s" % (
            apDisplay.timeString(time.time() - t0))

    return radonimagelist
def radonlist(imagelist, stepsize=2, maskrad=None, msg=None):
	"""
	computes Radon transform of image list
	"""
	if msg is None and len(imagelist) > 50:
		msg = True
	elif msg is None:
		msg = False

	### Note: multiprocessing version not compatible with python 2.4
	from multiprocessing import Queue, Process
	t0 = time.time()

	### prepare mask
	shape = imagelist[0].shape
	if maskrad is None:
		maskrad = shape[0]/2
	blackcircle = imagefun.filled_circle(shape, maskrad)
	mask = 1 - blackcircle

	### preform radon transform for each image
	queuelist = []
	if msg is True:
		apDisplay.printMsg("Performing Radon transforms with multiprocessor")
	for imageid in range(len(imagelist)):
		if msg is True and imageid % 50 == 0:
			### FUTURE: add time estimate
			sys.stderr.write(".")
		image = imagelist[imageid]
		queue = Queue()
		queuelist.append(queue)
		#below is equivalent to "radonImage(image, imageid, stepsize, mask, queue)"
		proc = Process(target=radonImage, args=(image, imageid, stepsize, mask, queue))
		proc.start()
	proc.join()

	### assemble radon image list
	radonimagelist = range(len(imagelist))
	for queue in queuelist:
		imageid, radonimage = queue.get()
		radonimagelist[imageid] = radonimage
	if msg is True:
		sys.stderr.write("\n")
		print "Multi Radon images complete in %s"%(apDisplay.timeString(time.time()-t0))

	return radonimagelist
def classicradon(image, stepsize=2):
	"""
	computes Radon transform of image
	"""
	radonlist = []
	nsteps = int(math.ceil(180/stepsize))
	blackcircle = imagefun.filled_circle(image.shape, image.shape[0]/2*0.75)
	mask = 1 - blackcircle
	maskline = mask.sum(axis=0) + 1
	for i in range(nsteps):
		rotated = ndimage.rotate(image, -i*stepsize, reshape=False, order=1)
		rotated = mask*rotated
		line = rotated.sum(axis=0)
		radonlist.append(line/maskline)
	radon = numpy.array(radonlist)
	radon = radon/radon.std()
	#radonlr = numpy.fliplr(radon)
	#radon = numpy.vstack((radon, radonlr))
	return radon
def project(image, row, angle, mask, queue):
	#print "%d, angle=%.3f"%(row, angle)
	### prepare mask
	if mask is None:
		maskrad = image.shape[0]/2	
		blackcircle = imagefun.filled_circle(image.shape, maskrad)
		mask = 1 - blackcircle
	maskline = mask.sum(axis=0) + 1

	### rotate and project image
	rotated = ndimage.rotate(image, angle, reshape=False, order=1)
	rotated = mask*rotated
	#imagefile.arrayToJpeg(rotated, "rotated%02d.jpg"%(row))
	line = rotated.sum(axis=0)

	### insert into radon array
	#print "insert %d, %.3f"%(row, line.mean())
	line = line/maskline
	queue.put([row, line])
	return
def project(image, row, angle, mask, queue):
    #print "%d, angle=%.3f"%(row, angle)
    ### prepare mask
    if mask is None:
        maskrad = image.shape[0] / 2
        blackcircle = imagefun.filled_circle(image.shape, maskrad)
        mask = 1 - blackcircle
    maskline = mask.sum(axis=0) + 1

    ### rotate and project image
    rotated = ndimage.rotate(image, angle, reshape=False, order=1)
    rotated = mask * rotated
    #imagefile.arrayToJpeg(rotated, "rotated%02d.jpg"%(row))
    line = rotated.sum(axis=0)

    ### insert into radon array
    #print "insert %d, %.3f"%(row, line.mean())
    line = line / maskline
    queue.put([row, line])
    return
示例#10
0
def classicradon(image, stepsize=2):
    """
	computes Radon transform of image
	"""
    radonlist = []
    nsteps = int(math.ceil(180 / stepsize))
    blackcircle = imagefun.filled_circle(image.shape,
                                         image.shape[0] / 2 * 0.75)
    mask = 1 - blackcircle
    maskline = mask.sum(axis=0) + 1
    for i in range(nsteps):
        rotated = ndimage.rotate(image, -i * stepsize, reshape=False, order=1)
        rotated = mask * rotated
        line = rotated.sum(axis=0)
        radonlist.append(line / maskline)
    radon = numpy.array(radonlist)
    radon = radon / radon.std()
    #radonlr = numpy.fliplr(radon)
    #radon = numpy.vstack((radon, radonlr))
    return radon
def radonTransform(image, stepsize=2, maskrad=None):
        """
        computes Radon transform of image
        """
        radonlist = []
        if maskrad is None:
                maskrad = image.shape[0]/2      
        blackcircle = imagefun.filled_circle(image.shape, maskrad)
        mask = 1 - blackcircle
        maskline = mask.sum(axis=0) + 1

        nsteps = int(math.ceil(180/stepsize))
        for i in range(nsteps):
                rotated = ndimage.rotate(image, -i*stepsize, reshape=False, order=1)
                rotated = mask*rotated
                line = rotated.sum(axis=0)
                radonlist.append(line/maskline)
        radon = numpy.array(radonlist)
        #radonlr = numpy.fliplr(radon)
        #radon = numpy.vstack((radon, radonlr))
        return radon
def radonTransform(image, stepsize=2, maskrad=None):
	"""
	computes Radon transform of image
	"""
	radonlist = []
	if maskrad is None:
		maskrad = image.shape[0]/2	
	blackcircle = imagefun.filled_circle(image.shape, maskrad)
	mask = 1 - blackcircle
	maskline = mask.sum(axis=0) + 1

	nsteps = int(math.ceil(180/stepsize))
	for i in range(nsteps):
		rotated = ndimage.rotate(image, -i*stepsize, reshape=False, order=1)
		rotated = mask*rotated
		line = rotated.sum(axis=0)
		radonlist.append(line/maskline)
	radon = numpy.array(radonlist)
	#radonlr = numpy.fliplr(radon)
	#radon = numpy.vstack((radon, radonlr))
	return radon