def ncc_segment(self, segment1, segments2, tol):
shape = [tol, tol]
region1 = segment1.get_image_region()
scale = segment1.get_segmented_image().get_scale()
i1 = segments2.get_img().get_data()
i1 = nputils.zoom(i1, region1.get_center(), [2 * tol, 2 * tol])
i2 = region1.get_region()
mask = (i2 > 0)
if min(region1.get_region().shape) <= 3:
return None
if self.mode == 'ncc':
ncc = nputils.norm_xcorr2(i1, i2, mode='same')
ncc[ncc < self.ncc_threshold] = 0
# ncc = nputils.weighted_norm_xcorr2(i1, i2, (i2 > 0), mode='same')
data = nputils.resize(ncc, shape)
elif self.mode == 'ncc_peaks':
data = np.zeros(shape)
ncc = nputils.norm_xcorr2(i1, i2, mode='same')
ncc = nputils.resize(ncc, shape)
peaks = nputils.find_peaks(ncc,
4,
self.ncc_threshold,
fit_gaussian=False)
for peak in peaks[:]:
data += imgutils.gaussian(shape, width=8,
center=peak) * ncc[tuple(peak)]
return data
def plot_result(self):
global_ncc = self.get_global_ncc(smooth_len=5)
if isinstance(global_ncc, np.ndarray):
mean_global_ncc_scales = self.get_mean_ncc_scales(smooth_len=5)
fig, ax0 = self.stack.add_subplots("Global NCC", ncols=1)
peaks = nputils.find_peaks(global_ncc,
3,
global_ncc.mean() +
2 * global_ncc.std(),
fit_gaussian=True)
peaks = sorted(peaks,
key=lambda p: global_ncc[tuple(p)],
reverse=True)
if len(peaks) < 10:
for peak in peaks:
p = (np.array(peak) / float(self.factor) -
np.array([self.bounds[0], self.bounds[2]]))
print "Peak at %s (norm:%s, intensity:%s, pix:%s)" % (
p[::-1], np.linalg.norm(p), global_ncc[tuple(peak)],
peak)
ax0.imshow(global_ncc, extent=self.global_ncc_extent)
plotutils.img_axis(ax0)
for scale, ncc in nputils.get_items_sorted_by_keys(
mean_global_ncc_scales):
if ncc.ndim != 2:
continue
fig, ax = self.stack.add_subplots("Global NCC scale %s" %
scale,
ncols=1)
ax.imshow(ncc, extent=self.global_ncc_extent)
plotutils.img_axis(ax)
def ncc_segment(self, segment1, segments2, tol):
shape = [tol, tol]
region1 = segment1.get_image_region()
scale = segment1.get_segmented_image().get_scale()
i1 = segments2.get_img().get_data()
i1 = nputils.zoom(i1, region1.get_center(), [2 * tol, 2 * tol])
i2 = region1.get_region()
mask = (i2 > 0)
if min(region1.get_region().shape) <= 3:
return None
if self.mode == 'ncc':
ncc = nputils.norm_xcorr2(i1, i2, mode='same')
ncc[ncc < self.ncc_threshold] = 0
# ncc = nputils.weighted_norm_xcorr2(i1, i2, (i2 > 0), mode='same')
data = nputils.resize(ncc, shape)
elif self.mode == 'ncc_peaks':
data = np.zeros(shape)
ncc = nputils.norm_xcorr2(i1, i2, mode='same')
ncc = nputils.resize(ncc, shape)
peaks = nputils.find_peaks(ncc, 4, self.ncc_threshold, fit_gaussian=False)
for peak in peaks[:]:
data += imgutils.gaussian(shape, width=8, center=peak) * ncc[tuple(peak)]
return data
def from_img_peaks(Klass, img, width, threashold, feature_filter=None,
fit_gaussian=False, exclude_border_dist=1):
'''Detect local maxima in an image and return a corresponding :class:`FeaturesGroup`.
Parameters
----------
img : :class:`libwise.imgutils.Image`
The image to analyse.
width : int
The typical width of the features to detect.
threashold : float
Threshold above which a local maxima is considered a feature.
feature_filter : :class:`FeatureFilter`, optional
Filter the features.
fit_gaussian : bool, optional
If true, a sub pixel coordinate position is estimated by fitting a 2D
gaussian profile on the feature.
exclude_border_dist : int, optional
Exclude features which are at distance < `exclude_border_dist` from
teh image border.
'''
width = max(width, 2)
img_meta = img.get_meta()
threashold_pics_coord = nputils.find_peaks(img.data, width, threashold, exclude_border=False,
fit_gaussian=fit_gaussian,
exclude_border_dist=exclude_border_dist)
result = Klass()
for coord in threashold_pics_coord:
pic_max = img.data[tuple(coord)]
snr = pic_max / float(threashold)
feature = ImageFeature(coord, img_meta, pic_max, snr)
if feature_filter is not None:
res = feature_filter.filter(feature)
if res is False:
continue
result.add_feature(feature)
return result
def from_img_peaks(Klass, img, width, threashold, feature_filter=None,
fit_gaussian=False, exclude_border_dist=1):
'''Detect local maxima in an image and return a corresponding :class:`FeaturesGroup`.
Parameters
----------
img : :class:`libwise.imgutils.Image`
The image to analyse.
width : int
The typical width of the features to detect.
threashold : float
Threshold above which a local maxima is considered a feature.
feature_filter : :class:`FeatureFilter`, optional
Filter the features.
fit_gaussian : bool, optional
If true, a sub pixel coordinate position is estimated by fitting a 2D
gaussian profile on the feature.
exclude_border_dist : int, optional
Exclude features which are at distance < `exclude_border_dist` from
teh image border.
'''
width = max(width, 2)
img_meta = img.get_meta()
threashold_pics_coord = nputils.find_peaks(img.data, width, threashold, exclude_border=False,
fit_gaussian=fit_gaussian,
exclude_border_dist=exclude_border_dist)
result = Klass()
for coord in threashold_pics_coord:
pic_max = img.data[tuple(coord)]
snr = pic_max / float(threashold)
feature = ImageFeature(coord, img_meta, pic_max, snr)
if feature_filter is not None:
res = feature_filter.filter(feature)
if res is False:
continue
result.add_feature(feature)
return result
def plot_result(self):
global_ncc = self.get_global_ncc(smooth_len=5)
if isinstance(global_ncc, np.ndarray):
mean_global_ncc_scales = self.get_mean_ncc_scales(smooth_len=5)
fig, ax0 = self.stack.add_subplots("Global NCC", ncols=1)
peaks = nputils.find_peaks(global_ncc, 3, global_ncc.mean() + 2 * global_ncc.std(), fit_gaussian=True)
peaks = sorted(peaks, key=lambda p: global_ncc[tuple(p)], reverse=True)
if len(peaks) < 10:
for peak in peaks:
p = (np.array(peak) / float(self.factor) - np.array([self.bounds[0], self.bounds[2]]))
print "Peak at %s (norm:%s, intensity:%s, pix:%s)" % (p[::-1], np.linalg.norm(p), global_ncc[tuple(peak)], peak)
ax0.imshow(global_ncc, extent=self.global_ncc_extent)
plotutils.img_axis(ax0)
for scale, ncc in nputils.get_items_sorted_by_keys(mean_global_ncc_scales):
if ncc.ndim != 2:
continue
fig, ax = self.stack.add_subplots("Global NCC scale %s" % scale, ncols=1)
ax.imshow(ncc, extent=self.global_ncc_extent)
plotutils.img_axis(ax)
def process(self, prj, res1, res2):
delta_t, velocity_pix, tol_pix = self.get_velocity_resolution(
prj, res1, res2)
max_bounds = max(self.bounds)
if self.verbose:
print "Processing:", res1.get_epoch(), res2.get_epoch(
), delta_t, velocity_pix, tol_pix
if self.debug >= 2:
fig, ax_check0 = self.stack.add_subplots("Segments check 1",
ncols=1)
fig, ax_check1 = self.stack.add_subplots("Segments check 2",
ncols=1)
epoch_all_mean_ncc = []
for segments1, segments2 in zip(res1, res2):
if self.debug >= 2:
imshow_segmented_image(ax_check0,
segments1,
alpha=1,
projection=prj)
imshow_segmented_image(ax_check1,
segments2,
alpha=1,
projection=prj)
scale = segments1.get_scale()
# print "Scale %s: %s" % (scale, len(segments1))
all_ncc = []
all_ncc_shape = None
for segment1 in segments1:
x_dir = self.x_dir
if x_dir == 'position_angle':
x_dir = prj.p2s(p2i(segment1.get_coord()))
elif nputils.is_callable(x_dir):
x_dir = self.x_dir(prj.p2s(p2i(segment1.get_coord())))
if self.mode == 'ncc_peaks_direct':
region1 = segment1.get_image_region()
if min(region1.get_region().shape) <= 3:
continue
if self.rnd_pos_shift:
shift = np.random.normal(
0,
self.rnd_pos_factor *
segment1.get_coord_error(min_snr=3))
region1.set_shift(shift)
i1 = segments2.get_img().get_data()
# i1 = nputils.shift2d(i1, np.array([4 / velocity_pix] * 2))
i1 = nputils.zoom(i1, region1.get_center(),
[2 * tol_pix, 2 * tol_pix])
i2 = region1.get_region()
shape = [
self.factor * (self.bounds[0] + self.bounds[1]),
self.factor * (self.bounds[2] + self.bounds[3])
]
data = np.zeros(shape)
# print i1.shape, i2.shape
ncc = nputils.norm_xcorr2(i1, i2, mode='same')
peaks = nputils.find_peaks(ncc,
4,
self.ncc_threshold,
fit_gaussian=False)
if len(peaks) > 0:
delta_pix = p2i(peaks - np.array(ncc.shape) / 2)
delta = prj.pixel_scales() * np.array(
delta_pix) * prj.unit
v = delta / self.__get_delta_time(delta_t)
if self.vel_trans:
v = self.vel_trans(
prj.p2s(p2i(segment1.get_coord())), v.T).T
if x_dir is not None:
vx, vy = nputils.vector_projection(v.T,
x_dir) * v.unit
else:
vx, vy = v.T
vx = vx.to(self.unit).value
vy = vy.to(self.unit).value
d = np.array([vx, vy])
if len(vx) > 0:
ix = self.factor * (self.bounds[0] + vx)
iy = self.factor * (self.bounds[2] + vy)
widths = np.array(
[[4 * self.factor * velocity_pix] * 2] *
len(peaks))
# widths = np.array([[1] * 2] * len(peaks))
centers = np.array([iy, ix]).T
heights = ncc[tuple(
np.array([tuple(k) for k in peaks]).T)]
# print widths, centers, heights
data = imgutils.multiple_gaussian(
shape, heights, widths, centers)
ncc = data
else:
ncc = self.ncc_segment(segment1, segments2, 2 * tol_pix)
if ncc is not None:
# print ncc.shape, nputils.coord_max(ncc)
ncc = zoom(ncc, velocity_pix * self.factor, order=3)
# zoom will shift the center
ncc = nputils.shift2d(
ncc, [-(velocity_pix * self.factor) / 2.] * 2)
# print ncc.shape, nputils.coord_max(ncc), velocity_pix * self.factor
ncc = nputils.zoom(ncc,
np.array(ncc.shape) / 2, [
2 * max_bounds * self.factor,
2 * max_bounds * self.factor
])
# print ncc.shape, nputils.coord_max(ncc)
# ncc = ncc[self.factor * (max_bounds - self.bounds[0]):self.factor * (max_bounds + self.bounds[1]),
# self.factor * (max_bounds - self.bounds[2]):self.factor * (max_bounds + self.bounds[3])]
# print ncc.shape
if x_dir is not None:
angle_rad = -np.arctan2(x_dir[1], x_dir[0])
ncc = rotate(ncc,
-angle_rad / (2 * np.pi) * 360,
reshape=False,
order=2)
if ncc is not None:
if self.debug >= 3:
fig, (ax0, ax1, ax2) = self.stack.add_subplots(
"Segment %s" % segment1.get_segmentid(), ncols=3)
r1 = segment1.get_image_region()
ax0.imshow(r1.get_region())
i2 = nputils.zoom(segments2.get_img().get_data(),
r1.get_center(),
[2 * tol_pix, 2 * tol_pix])
ax1.imshow(i2,
norm=plotutils.LogNorm(),
extent=(-tol_pix, tol_pix, -tol_pix,
tol_pix))
plotutils.img_axis(ax1)
ax2.imshow(ncc, extent=self.global_ncc_extent)
plotutils.img_axis(ax2)
all_ncc.append(ncc)
if all_ncc_shape is None:
all_ncc_shape = ncc.shape
if len(all_ncc) > 0:
if scale not in self.global_ncc_scales:
self.global_ncc_scales[scale] = []
self.global_ncc_scales_n[scale] = 0
mean_ncc = self.agg_fct(np.array(all_ncc), axis=0)
epoch_all_mean_ncc.append(mean_ncc)
if self.debug >= 1:
fig, ax = self.stack.add_subplots(
"Ncc epoch %s vs %s scale %s" %
(res1.get_epoch(), res2.get_epoch(), scale))
ax.imshow(mean_ncc, extent=self.global_ncc_extent)
plotutils.img_axis(ax)
self.global_ncc_scales[scale].append(mean_ncc)
self.global_ncc_scales_n[scale] += len(all_ncc)
if self.debug >= 0.5 and len(epoch_all_mean_ncc) > 0:
epoch_mean_ncc = self.agg_fct(np.array(epoch_all_mean_ncc), axis=0)
fig, ax = self.stack.add_subplots(
"Ncc epoch %s vs %s" % (res1.get_epoch(), res2.get_epoch()))
ax.imshow(epoch_mean_ncc, extent=self.global_ncc_extent)
plotutils.img_axis(ax)
def process(self, prj, res1, res2):
delta_t, velocity_pix, tol_pix = self.get_velocity_resolution(prj, res1, res2)
max_bounds = max(self.bounds)
if self.verbose:
print "Processing:", res1.get_epoch(), res2.get_epoch(), delta_t, velocity_pix, tol_pix
if self.debug >= 2:
fig, ax_check0 = self.stack.add_subplots("Segments check 1", ncols=1)
fig, ax_check1 = self.stack.add_subplots("Segments check 2", ncols=1)
epoch_all_mean_ncc = []
for segments1, segments2 in zip(res1, res2):
if self.debug >= 2:
imshow_segmented_image(ax_check0, segments1, alpha=1, projection=prj)
imshow_segmented_image(ax_check1, segments2, alpha=1, projection=prj)
scale = segments1.get_scale()
# print "Scale %s: %s" % (scale, len(segments1))
all_ncc = []
all_ncc_shape = None
for segment1 in segments1:
x_dir = self.x_dir
if x_dir == 'position_angle':
x_dir = prj.p2s(p2i(segment1.get_coord()))
elif nputils.is_callable(x_dir):
x_dir = self.x_dir(prj.p2s(p2i(segment1.get_coord())))
if self.mode == 'ncc_peaks_direct':
region1 = segment1.get_image_region()
if min(region1.get_region().shape) <= 3:
continue
if self.rnd_pos_shift:
shift = np.random.normal(0, self.rnd_pos_factor * segment1.get_coord_error(min_snr=3))
region1.set_shift(shift)
i1 = segments2.get_img().get_data()
# i1 = nputils.shift2d(i1, np.array([4 / velocity_pix] * 2))
i1 = nputils.zoom(i1, region1.get_center(), [2 * tol_pix, 2 * tol_pix])
i2 = region1.get_region()
shape = [self.factor * (self.bounds[0] + self.bounds[1]), self.factor * (self.bounds[2] + self.bounds[3])]
data = np.zeros(shape)
# print i1.shape, i2.shape
ncc = nputils.norm_xcorr2(i1, i2, mode='same')
peaks = nputils.find_peaks(ncc, 4, self.ncc_threshold, fit_gaussian=False)
if len(peaks) > 0:
delta_pix = p2i(peaks - np.array(ncc.shape) / 2)
delta = prj.pixel_scales() * np.array(delta_pix) * prj.unit
v = delta / self.__get_delta_time(delta_t)
if self.vel_trans:
v = self.vel_trans(prj.p2s(p2i(segment1.get_coord())), v.T).T
if x_dir is not None:
vx, vy = nputils.vector_projection(v.T, x_dir) * v.unit
else:
vx, vy = v.T
vx = vx.to(self.unit).value
vy = vy.to(self.unit).value
d = np.array([vx, vy])
if len(vx) > 0:
ix = self.factor * (self.bounds[0] + vx)
iy = self.factor * (self.bounds[2] + vy)
widths = np.array([[4 * self.factor * velocity_pix] * 2] * len(peaks))
# widths = np.array([[1] * 2] * len(peaks))
centers = np.array([iy, ix]).T
heights = ncc[tuple(np.array([tuple(k) for k in peaks]).T)]
# print widths, centers, heights
data = imgutils.multiple_gaussian(shape, heights, widths, centers)
ncc = data
else:
ncc = self.ncc_segment(segment1, segments2, 2 * tol_pix)
if ncc is not None:
# print ncc.shape, nputils.coord_max(ncc)
ncc = zoom(ncc, velocity_pix * self.factor, order=3)
# zoom will shift the center
ncc = nputils.shift2d(ncc, [- (velocity_pix * self.factor) / 2.] * 2)
# print ncc.shape, nputils.coord_max(ncc), velocity_pix * self.factor
ncc = nputils.zoom(ncc, np.array(ncc.shape) / 2, [2 * max_bounds * self.factor, 2 * max_bounds * self.factor])
# print ncc.shape, nputils.coord_max(ncc)
# ncc = ncc[self.factor * (max_bounds - self.bounds[0]):self.factor * (max_bounds + self.bounds[1]),
# self.factor * (max_bounds - self.bounds[2]):self.factor * (max_bounds + self.bounds[3])]
# print ncc.shape
if x_dir is not None:
angle_rad = - np.arctan2(x_dir[1], x_dir[0])
ncc = rotate(ncc, - angle_rad / (2 * np.pi) * 360, reshape=False, order=2)
if ncc is not None:
if self.debug >= 3:
fig, (ax0, ax1, ax2) = self.stack.add_subplots("Segment %s" % segment1.get_segmentid(), ncols=3)
r1 = segment1.get_image_region()
ax0.imshow(r1.get_region())
i2 = nputils.zoom(segments2.get_img().get_data(), r1.get_center(), [2 * tol_pix, 2 * tol_pix])
ax1.imshow(i2, norm=plotutils.LogNorm(),
extent=(-tol_pix, tol_pix, -tol_pix, tol_pix))
plotutils.img_axis(ax1)
ax2.imshow(ncc, extent=self.global_ncc_extent)
plotutils.img_axis(ax2)
all_ncc.append(ncc)
if all_ncc_shape is None:
all_ncc_shape = ncc.shape
if len(all_ncc) > 0:
if scale not in self.global_ncc_scales:
self.global_ncc_scales[scale] = []
self.global_ncc_scales_n[scale] = 0
mean_ncc = self.agg_fct(np.array(all_ncc), axis=0)
epoch_all_mean_ncc.append(mean_ncc)
if self.debug >= 1:
fig, ax = self.stack.add_subplots("Ncc epoch %s vs %s scale %s" % (res1.get_epoch(), res2.get_epoch(), scale))
ax.imshow(mean_ncc, extent=self.global_ncc_extent)
plotutils.img_axis(ax)
self.global_ncc_scales[scale].append(mean_ncc)
self.global_ncc_scales_n[scale] += len(all_ncc)
if self.debug >= 0.5 and len(epoch_all_mean_ncc) > 0:
epoch_mean_ncc = self.agg_fct(np.array(epoch_all_mean_ncc), axis=0)
fig, ax = self.stack.add_subplots("Ncc epoch %s vs %s" % (res1.get_epoch(), res2.get_epoch()))
ax.imshow(epoch_mean_ncc, extent=self.global_ncc_extent)
plotutils.img_axis(ax)
