def __init__(self, csvfile="table.csv"):
with open(csvfile) as csvfile:
reader = csv.reader(csvfile, skipinitialspace=True)
self.header = [markup(x) for x in next(reader)]
self.append(self.header)
for row in reader:
is_image_file = row[0].startswith("file://")
if is_image_file:
images = []
for filenames in row:
images.append([
load_image(filename=f.replace("file://", ""))
for f in filenames.split("|")
])
self.append(images)
else:
self.append(row)
print(self.header)
def seeds(args):
"""
%prog seeds [pngfile|jpgfile]
Extract seed metrics from [pngfile|jpgfile]. Use --rows and --cols to crop image.
"""
p = OptionParser(seeds.__doc__)
p.set_outfile()
opts, args, iopts = add_seeds_options(p, args)
if len(args) != 1:
sys.exit(not p.print_help())
(pngfile, ) = args
pf = opts.prefix or op.basename(pngfile).rsplit(".", 1)[0]
sigma, kernel = opts.sigma, opts.kernel
rows, cols = opts.rows, opts.cols
labelrows, labelcols = opts.labelrows, opts.labelcols
ff = opts.filter
calib = opts.calibrate
outdir = opts.outdir
if outdir != ".":
mkdir(outdir)
if calib:
calib = json.load(must_open(calib))
pixel_cm_ratio, tr = calib["PixelCMratio"], calib["RGBtransform"]
tr = np.array(tr)
nbcolor = opts.changeBackground
pngfile = convert_background(pngfile, nbcolor)
resizefile, mainfile, labelfile, exif = convert_image(
pngfile,
pf,
outdir=outdir,
rotate=opts.rotate,
rows=rows,
cols=cols,
labelrows=labelrows,
labelcols=labelcols,
)
oimg = load_image(resizefile)
img = load_image(mainfile)
fig, (ax1, ax2, ax3, ax4) = plt.subplots(ncols=4,
nrows=1,
figsize=(iopts.w, iopts.h))
# Edge detection
img_gray = rgb2gray(img)
logging.debug("Running {0} edge detection ...".format(ff))
if ff == "canny":
edges = canny(img_gray, sigma=opts.sigma)
elif ff == "roberts":
edges = roberts(img_gray)
elif ff == "sobel":
edges = sobel(img_gray)
edges = clear_border(edges, buffer_size=opts.border)
selem = disk(kernel)
closed = closing(edges, selem) if kernel else edges
filled = binary_fill_holes(closed)
# Watershed algorithm
if opts.watershed:
distance = distance_transform_edt(filled)
local_maxi = peak_local_max(distance,
threshold_rel=0.05,
indices=False)
coordinates = peak_local_max(distance, threshold_rel=0.05)
markers, nmarkers = label(local_maxi, return_num=True)
logging.debug("Identified {0} watershed markers".format(nmarkers))
labels = watershed(closed, markers, mask=filled)
else:
labels = label(filled)
# Object size filtering
w, h = img_gray.shape
canvas_size = w * h
min_size = int(round(canvas_size * opts.minsize / 100))
max_size = int(round(canvas_size * opts.maxsize / 100))
logging.debug(
"Find objects with pixels between {0} ({1}%) and {2} ({3}%)".format(
min_size, opts.minsize, max_size, opts.maxsize))
# Plotting
ax1.set_title("Original picture")
ax1.imshow(oimg)
params = "{0}, $\sigma$={1}, $k$={2}".format(ff, sigma, kernel)
if opts.watershed:
params += ", watershed"
ax2.set_title("Edge detection\n({0})".format(params))
closed = gray2rgb(closed)
ax2_img = labels
if opts.edges:
ax2_img = closed
elif opts.watershed:
ax2.plot(coordinates[:, 1], coordinates[:, 0], "g.")
ax2.imshow(ax2_img, cmap=iopts.cmap)
ax3.set_title("Object detection")
ax3.imshow(img)
filename = op.basename(pngfile)
if labelfile:
accession = extract_label(labelfile)
else:
accession = pf
# Calculate region properties
rp = regionprops(labels)
rp = [x for x in rp if min_size <= x.area <= max_size]
nb_labels = len(rp)
logging.debug("A total of {0} objects identified.".format(nb_labels))
objects = []
for i, props in enumerate(rp):
i += 1
if i > opts.count:
break
y0, x0 = props.centroid
orientation = props.orientation
major, minor = props.major_axis_length, props.minor_axis_length
major_dx = cos(orientation) * major / 2
major_dy = sin(orientation) * major / 2
minor_dx = sin(orientation) * minor / 2
minor_dy = cos(orientation) * minor / 2
ax2.plot((x0 - major_dx, x0 + major_dx),
(y0 + major_dy, y0 - major_dy), "r-")
ax2.plot((x0 - minor_dx, x0 + minor_dx),
(y0 - minor_dy, y0 + minor_dy), "r-")
npixels = int(props.area)
# Sample the center of the blob for color
d = min(int(round(minor / 2 * 0.35)) + 1, 50)
x0d, y0d = int(round(x0)), int(round(y0))
square = img[(y0d - d):(y0d + d), (x0d - d):(x0d + d)]
pixels = []
for row in square:
pixels.extend(row)
logging.debug("Seed #{0}: {1} pixels ({2} sampled) - {3:.2f}%".format(
i, npixels, len(pixels), 100.0 * npixels / canvas_size))
rgb = pixel_stats(pixels)
objects.append(Seed(filename, accession, i, rgb, props, exif))
minr, minc, maxr, maxc = props.bbox
rect = Rectangle((minc, minr),
maxc - minc,
maxr - minr,
fill=False,
ec="w",
lw=1)
ax3.add_patch(rect)
mc, mr = (minc + maxc) / 2, (minr + maxr) / 2
ax3.text(mc,
mr,
"{0}".format(i),
color="w",
ha="center",
va="center",
size=6)
for ax in (ax2, ax3):
ax.set_xlim(0, h)
ax.set_ylim(w, 0)
# Output identified seed stats
ax4.text(0.1, 0.92, "File: {0}".format(latex(filename)), color="g")
ax4.text(0.1, 0.86, "Label: {0}".format(latex(accession)), color="m")
yy = 0.8
fw = must_open(opts.outfile, "w")
if not opts.noheader:
print(Seed.header(calibrate=calib), file=fw)
for o in objects:
if calib:
o.calibrate(pixel_cm_ratio, tr)
print(o, file=fw)
i = o.seedno
if i > 7:
continue
ax4.text(0.01, yy, str(i), va="center", bbox=dict(fc="none", ec="k"))
ax4.text(0.1, yy, o.pixeltag, va="center")
yy -= 0.04
ax4.add_patch(
Rectangle((0.1, yy - 0.025),
0.12,
0.05,
lw=0,
fc=rgb_to_hex(o.rgb)))
ax4.text(0.27, yy, o.hashtag, va="center")
yy -= 0.06
ax4.text(
0.1,
yy,
"(A total of {0} objects displayed)".format(nb_labels),
color="darkslategray",
)
normalize_axes(ax4)
for ax in (ax1, ax2, ax3):
xticklabels = [int(x) for x in ax.get_xticks()]
yticklabels = [int(x) for x in ax.get_yticks()]
ax.set_xticklabels(xticklabels, family="Helvetica", size=8)
ax.set_yticklabels(yticklabels, family="Helvetica", size=8)
image_name = op.join(outdir, pf + "." + iopts.format)
savefig(image_name, dpi=iopts.dpi, iopts=iopts)
return objects