def execute(self):
padded_bcube = self.bcube.uncrop(self.pad, self.mip)
for k, specs in enumerate(self.src_specs[::-1]):
z = specs['src_z']
mask_id = specs['mask_id']
bcube = padded_bcube.reset_coords(zs=z, ze=z+1, in_place=False)
imgs = {}
for name in ['src_img', 'src_mask', 'src_field']:
layer = self.src_layers[str(specs[name])]
if name == 'src_mask':
layer.binarizer = helpers.Binarizer(['eq', mask_id])
imgs[name] = layer.read(bcube=bcube, mip=self.mip)
mask = residuals.res_warp_img(imgs['src_mask'].float(),
imgs['src_field'])
mask = (mask > 0.4).bool()
cropped_mask = helpers.crop(mask, self.pad)
img = residuals.res_warp_img(imgs['src_img'].float(),
imgs['src_field'])
cropped_img = helpers.crop(img, self.pad)
if k == 0:
dst_img = cropped_img
dst_img[~cropped_mask] = 0
else:
dst_img[cropped_mask] = cropped_img[cropped_mask]
self.dst_layer.write(dst_img, bcube=self.bcube, mip=self.mip)
def execute(self):
src_bcube = self.bcube.uncrop(self.pad, self.mip)
tgt_bcube = src_bcube.translate(z_offset=self.tgt_z_offset)
processor = procspec.parse_proc(spec_str=self.processor_spec)
tgt_translation, tgt_data_dict = self.tgt_stack.read_data_dict(
tgt_bcube, mip=self.mip, stack_name='tgt')
# Compensate if target was moved to one side a lot
tgt_drift = helpers.percentile_trans_adjuster(
tgt_data_dict['tgt_agg_field'],
unaligned_img=tgt_data_dict['tgt_img'])
src_translation, src_data_dict = self.src_stack.read_data_dict(
src_bcube, mip=self.mip, stack_name='src', translation=tgt_drift)
#translation_adjuster=helpers.percentile_trans_adjuster)
processor_input = {**src_data_dict, **tgt_data_dict}
predicted_field = processor(processor_input, output_key='src_cf_field')
predicted_field.x += tgt_drift.x
predicted_field.y += tgt_drift.y
cropped_field = helpers.crop(predicted_field, self.crop)
self.dst_layer.write(cropped_field, bcube=self.bcube, mip=self.mip)
def execute(self):
corgie_logger.debug(f"ComputeFieldTask")
src_bcube = self.bcube.uncrop(self.pad, self.mip)
tgt_bcube = src_bcube.translate(z_offset=self.tgt_z_offset)
processor = procspec.parse_proc(spec_str=self.processor_spec)
corgie_logger.debug(f"Read target")
tgt_translation, tgt_data_dict = self.tgt_stack.read_data_dict(
tgt_bcube, mip=self.mip, stack_name="tgt")
# Compensate if target was moved to one side a lot
# tgt_drift = helpers.percentile_trans_adjuster(
# tgt_data_dict["tgt_agg_field"], unaligned_img=tgt_data_dict["tgt_img"]
# )
tgt_drift = helpers.Translation(0, 0)
corgie_logger.debug(f"Read source")
src_translation, src_data_dict = self.src_stack.read_data_dict(
src_bcube, mip=self.mip, stack_name="src", translation=tgt_drift)
# translation_adjuster=helpers.percentile_trans_adjuster)
# )
processor_input = {**src_data_dict, **tgt_data_dict}
corgie_logger.debug(f"Compute field")
predicted_field = processor(processor_input, output_key="src_cf_field")
predicted_field.x += tgt_drift.x
predicted_field.y += tgt_drift.y
cropped_field = helpers.crop(predicted_field, self.crop)
corgie_logger.debug(f"Write field")
self.dst_layer.write(cropped_field, bcube=self.bcube, mip=self.mip)
def execute(self):
src_bcube = self.bcube.uncrop(self.pad, self.mip)
src_data = self.src_layer.read(src_bcube, mip=self.mip)
result = (~src_data.field().from_pixels()).pixels()
cropped_result = helpers.crop(result, self.crop)
self.dst_layer.write(cropped_result, bcube=self.bcube, mip=self.mip)
def execute(self):
corgie_logger.debug(f"ComposeWithDistanceTask, {self.bcube}")
corgie_logger.debug(f"input_fields: {self.input_fields}")
corgie_logger.debug(f"z_list: {self.z_list}")
pbcube = self.bcube.uncrop(self.pad, self.mip)
fields = PyramidDistanceFieldSet(
decay_dist=self.decay_dist,
blur_rate=self.blur_rate,
layers=self.input_fields,
)
field = fields.read(bcube=pbcube, z_list=self.z_list, mip=self.mip)
cropped_field = helpers.crop(field, self.pad)
self.output_field.write(cropped_field, bcube=self.bcube, mip=self.mip)
def execute(self):
src_bcube = self.bcube.uncrop(self.pad, self.mip)
processor = procspec.parse_proc(spec_str=self.processor_spec)
src_translation, src_data_dict = self.src_stack.read_data_dict(
src_bcube, mip=self.mip, stack_name='src')
processor_input = {**src_data_dict}
result = processor(processor_input, output_key='output')
cropped_result = helpers.crop(result, self.crop)
self.dst_layer.write(cropped_result, bcube=self.bcube, mip=self.mip)
def execute(self):
device = "cuda" if torch.cuda.is_available() else "cpu"
padded_bcube = self.bcube.uncrop(self.pad, self.mip)
for k, specs in enumerate(self.src_specs[::-1]):
src_z = specs["src_z"]
dst_z = self.bcube.z_range()[0]
corgie_logger.info(f"Load fields for {padded_bcube}")
# backwards compatible
if not isinstance(specs["src_field"], list):
specs["src_field"] = [specs["src_field"]]
mask_layer = self.src_layers[str(specs["src_mask"])]
field_ids = list(map(str, specs["src_field"]))
corgie_logger.info(f"field ids={field_ids}")
z_list = specs.get("src_field_z", [src_z] * len(field_ids))
fields = FieldSet([self.src_layers[n] for n in field_ids])
field = fields.read(
bcube=padded_bcube, z_list=z_list, mip=self.mip, device=device
)
bcube = padded_bcube.reset_coords(zs=src_z, ze=src_z + 1, in_place=False)
mask_trans = helpers.percentile_trans_adjuster(field)
mask_trans = mask_trans.round_to_mip(self.mip, mask_layer.data_mip)
corgie_logger.debug(f"mask_trans: {mask_trans}")
mask_bcube = bcube.translate(
x_offset=mask_trans.y, y_offset=mask_trans.x, mip=self.mip
)
corgie_logger.info(f"Load masks for {mask_bcube}")
mask_id = specs["mask_id"]
mask_layer.binarizer = helpers.Binarizer(["eq", mask_id])
mask = mask_layer.read(bcube=mask_bcube, mip=self.mip, device=device)
mask = residuals.res_warp_img(
mask.float(), field - mask_trans.to_tensor(device=field.device)
).tensor()
mask = (mask > 0.4).bool()
cropped_mask = helpers.crop(mask, self.pad)
relabel_id = torch.as_tensor(specs.get("relabel_id", k + 1), dtype=torch.uint8)
if k == 0:
dst_img = cropped_mask * relabel_id
dst_img[~cropped_mask] = 0
else:
dst_img[cropped_mask] = cropped_mask[cropped_mask] * relabel_id
self.dst_layer.write(dst_img.cpu(), bcube=self.bcube, mip=self.mip)
def execute(self):
src_bcube = self.bcube.uncrop(self.pad, self.mip)
tgt_bcube = src_bcube.translate(z=self.tgt_z_offset)
processor = procspec.parse_proc(spec_str=self.processor_spec, default_output='src_cf_field')
src_translation, src_data_dict = self.src_stack.read_data_dict(src_bcube,
mip=self.mip, stack_name='src')
tgt_translation, tgt_data_dict = self.tgt_stack.read_data_dict(tgt_bcube,
mip=self.mip, stack_name='tgt')
processor_input = {**src_data_dict, **tgt_data_dict}
predicted_field = processor(processor_input)
cropped_field = helpers.crop(predicted_field, self.crop)
self.dst_layer.write(cropped_field, bcube=self.bcube, mip=self.mip)
def execute(self):
src_bcube = self.bcube.uncrop(self.pad, self.mip)
tgt_bcube = src_bcube.translate(z_offset=self.tgt_z_offset)
processor = procspec.parse_proc(spec_str=self.processor_spec)
_, tgt_data_dict = self.tgt_stack.read_data_dict(tgt_bcube,
mip=self.mip,
stack_name='tgt')
_, src_data_dict = self.src_stack.read_data_dict(src_bcube,
mip=self.mip,
stack_name='src')
processor_input = {**src_data_dict, **tgt_data_dict}
result = processor(processor_input, output_key='result')
cropped_result = helpers.crop(result, self.crop)
self.dst_layer.write(cropped_result, bcube=self.bcube, mip=self.mip)
def execute(self):
corgie_logger.debug(f"CombineMaskTask, {self.bcube}")
pbcube = self.bcube.uncrop(self.pad, self.mip)
bf = BoolFn(self.exp)
for z in range(*self.bcube.z_range()):
def eval(exp):
w, k, o = exp["weight"], exp["key"], exp["offset"]
bcube = pbcube.reset_coords(zs=z + o, ze=z + o + 1, in_place=False)
layer = self.src_stack.layers[k]
return w * layer.read(bcube=bcube, mip=self.mip)
m = bf(eval).to(torch.uint8)
m = helpers.crop(m, self.pad)
bcube = self.bcube.reset_coords(zs=z, ze=z + 1, in_place=False)
self.dst_layer.write(m, bcube=bcube, mip=self.mip)
# This task can be used with caching
for layer in self.src_stack.layers.values():
layer.flush(self.mip)
def execute(self):
corgie_logger.debug(f"BroadcastTask, {self.bcube}")
input_fields = self.stitching_fields[::-1]
if len(self.z_list) != len(input_fields):
fmul = len(self.z_list) // len(input_fields)
frem = len(self.z_list) % len(input_fields)
input_fields = input_fields[::-1]
input_fields = fmul * input_fields + input_fields[:frem]
input_fields = input_fields[::-1]
input_fields += [self.block_field]
z_list = self.z_list + [self.bcube.z_range()[0]]
corgie_logger.debug(f"input_fields: {input_fields}")
corgie_logger.debug(f"z_list: {z_list}")
pbcube = self.bcube.uncrop(self.pad, self.mip)
corgie_logger.debug(f"pbcube: {pbcube}")
fields = PyramidDistanceFieldSet(decay_dist=self.decay_dist,
blur_rate=self.blur_rate,
layers=input_fields)
field = fields.read(bcube=pbcube, z_list=z_list, mip=self.mip)
cropped_field = helpers.crop(field, self.pad)
self.output_field.write(cropped_field, bcube=self.bcube, mip=self.mip)
def execute(self):
src_bcube = self.bcube.uncrop(self.pad, self.mip)
tgt_bcube = src_bcube.translate(z_offset=self.tgt_z_offset)
processor = procspec.parse_proc(spec_str=self.processor_spec)
_, tgt_data_dict = self.tgt_stack.read_data_dict(tgt_bcube,
mip=self.mip,
stack_name="tgt")
_, src_data_dict = self.src_stack.read_data_dict(src_bcube,
mip=self.mip,
stack_name="src")
processor_input = {**src_data_dict, **tgt_data_dict}
result = processor(processor_input, output_key="result")
tgt_pixel_data = self.pixel_offset_layer.read(
bcube=self.bcube.translate(z_offset=self.tgt_z_offset),
mip=self.mip)
written_pixel_data = self.pixel_offset_layer.read(bcube=self.bcube,
mip=self.mip)
written_mask_data = self.dst_layer.read(bcube=self.bcube, mip=self.mip)
result = result.to(device=written_mask_data.device)
cropped_result = helpers.crop(result, self.crop)
if self.seethrough_limit > 0:
seethrough_mask = (cropped_result > 0) & (tgt_pixel_data <
self.seethrough_limit)
else:
seethrough_mask = cropped_result > 0
written_mask_data[seethrough_mask] = True
written_pixel_data[seethrough_mask] = (torch.minimum(
tgt_pixel_data[seethrough_mask],
torch.ones_like(tgt_pixel_data[seethrough_mask]) * 254,
) + 1)
self.dst_layer.write(written_mask_data, bcube=self.bcube, mip=self.mip)
self.pixel_offset_layer.write(written_pixel_data,
bcube=self.bcube,
mip=self.mip)
def execute(self):
tgt_bcube = self.bcube.uncrop(self.pad, self.mip)
_, tgt_data_dict = self.tgt_stack.read_data_dict(tgt_bcube,
mip=self.mip,
stack_name="tgt")
dst_layers = self.dst_stack.get_layers_of_type("img")
for dst_layer in dst_layers:
z_offset = int(dst_layer.name)
src_bcube = tgt_bcube.translate(z_offset=z_offset)
processor = procspec.parse_proc(spec_str=self.processor_spec)
_, src_data_dict = self.src_stack.read_data_dict(src_bcube,
mip=self.mip,
stack_name="src")
processor_input = {**src_data_dict, **tgt_data_dict}
result = processor(processor_input, output_key="result")
crop = self.pad // 2**(self.dst_mip - self.mip)
cropped_result = helpers.crop(result, crop)
dst_layer.write(cropped_result, bcube=self.bcube, mip=self.dst_mip)
def execute(self):
padded_bcube = self.bcube.uncrop(self.pad, self.mip)
for f in self.additional_fields:
self.src_stack.add_layer(f)
src_translation, src_data_dict = self.src_stack.read_data_dict(
padded_bcube, mip=self.mip, stack_name='src')
agg_field = src_data_dict[f"src_agg_field"]
if self.blackout_masks:
mask_layers = self.dst_stack.get_layers_of_type(["img", "mask"])
mask = helpers.read_mask_list(mask_layers, self.bcube, self.mip)
else:
mask = None
if self.render_masks:
write_layers = self.dst_stack.get_layers_of_type(["img", "mask"])
else:
write_layers = self.dst_stack.get_layers_of_type("img")
for l in write_layers:
src = src_data_dict[f"src_{l.name}"]
if agg_field is not None:
warped_src = residuals.res_warp_img(src.float(), agg_field)
else:
warped_src = src
if mask is not None:
warped_src[mask] = 0.0
cropped_out = helpers.crop(warped_src, self.pad)
l.write(cropped_out, bcube=self.bcube, mip=self.mip)
for f in self.additional_fields:
self.src_stack.remove_layer(f.name)
def execute(self):
padded_bcube = self.bcube.uncrop(self.pad, self.mip)
seethrough_bcube = self.bcube.translate(
z_offset=self.seethrough_offset)
for f in self.additional_fields:
#just in case the "additional" field is actually already a part of src_stack
if f not in self.src_stack.layers.values():
self.src_stack.add_layer(f)
src_translation, src_data_dict = self.src_stack.read_data_dict(
padded_bcube, mip=self.mip, add_prefix=False)
agg_field = src_data_dict[f"agg_field"]
agg_mask = None
if self.blackout_masks or self.seethrough:
mask_layers = self.dst_stack.get_layers_of_type(["mask"])
mask_layer_names = [l.name for l in mask_layers]
for n, d in six.iteritems(src_data_dict):
if n in mask_layer_names:
if agg_mask is None:
agg_mask = d
else:
agg_mask = ((agg_mask + d) > 0).byte()
if agg_mask is not None:
coarsen_factor = int(2**(6 - self.mip))
agg_mask = helpers.coarsen_mask(agg_mask, coarsen_factor)
if agg_field is not None:
warped_mask = residuals.res_warp_img(
agg_mask.float(), agg_field)
else:
warped_mask = agg_mask
warped_mask = (warped_mask > 0.4).byte()
else:
warped_mask = None
if self.render_masks:
write_layers = self.dst_stack.get_layers_of_type(["img", "mask"])
else:
write_layers = self.dst_stack.get_layers_of_type("img")
for l in write_layers:
src = src_data_dict[f"{l.name}"]
if agg_field is not None:
warped_src = residuals.res_warp_img(src.float(), agg_field)
else:
warped_src = src
cropped_out = helpers.crop(warped_src, self.pad)
if self.blackout_masks or self.seethrough:
if warped_mask is not None:
warped_mask = helpers.crop(warped_mask, self.pad)
if l.get_layer_type(
) == "img" and self.blackout_masks and warped_mask is not None:
cropped_out[warped_mask] = self.blackout_value
if l.get_layer_type(
) == "img" and self.seethrough and warped_mask is not None:
seethrough_data = l.read(bcube=seethrough_bcube,
mip=self.mip)
coarsen_factor = int(2**(6 - self.mip))
seethrough_mask = helpers.coarsen_mask(
warped_mask, coarsen_factor)
seethrough_mask[cropped_out == 0] = True
cropped_out[seethrough_mask] = \
seethrough_data[seethrough_mask]
seenthru = (cropped_out[seethrough_mask] != 0).sum()
corgie_logger.debug(f"Seenthrough {seenthru} pixels")
l.write(cropped_out, bcube=self.bcube, mip=self.mip)
def execute(self):
padded_bcube = self.bcube.uncrop(self.pad, self.mip)
for f in self.additional_fields:
# just in case the "additional" field is actually already a part of src_stack
if f not in self.src_stack.layers.values():
self.src_stack.add_layer(f)
src_translation, src_data_dict = self.src_stack.read_data_dict(
padded_bcube,
mip=self.mip,
add_prefix=False,
translation_adjuster=helpers.percentile_trans_adjuster,
)
agg_field = src_data_dict[f"agg_field"]
if agg_field is not None:
agg_field[:, 0] -= src_translation.x
agg_field[:, 1] -= src_translation.y
# Produce and aggregate mask if there's a need to blackout all masks
agg_mask = None
if self.blackout_masks:
mask_layers = self.dst_stack.get_layers_of_type(["mask"])
mask_layer_names = [l.name for l in mask_layers]
for n, d in six.iteritems(src_data_dict):
if n in mask_layer_names:
if agg_mask is None:
agg_mask = d
else:
agg_mask = ((agg_mask + d) > 0).byte()
# if the mask is not empty, warp it and coarsen it for seethrough
if agg_mask is not None:
coarsen_factor = int(2**(6 - self.mip))
agg_mask = helpers.coarsen_mask(agg_mask, coarsen_factor)
if agg_field is not None:
warped_mask = residuals.res_warp_img(
agg_mask.float(), agg_field)
else:
warped_mask = agg_mask
warped_mask = (warped_mask > 0.4).byte()
# To save time, we won't be blacking out stuff that gets cropped anyway
warped_mask = helpers.crop(warped_mask, self.pad)
else:
warped_mask = None
if self.render_masks:
write_layers = self.dst_stack.get_layers_of_type(["img", "mask"])
else:
write_layers = self.dst_stack.get_layers_of_type("img")
for l in write_layers:
src = src_data_dict[f"{l.name}"]
'''
if (src != 0).sum():
import pdb; pdb.set_trace()
else:
return
'''
if agg_field is not None:
warped_src = residuals.res_warp_img(src.float(), agg_field)
else:
warped_src = src
cropped_out = helpers.crop(warped_src, self.pad)
if l.get_layer_type() == "img":
if self.blackout_masks and warped_mask is not None:
cropped_out[warped_mask] = self.blackout_value
if self.preserve_zeros and agg_field is not None:
src_zero_mask = src == 0
warped_zero_mask = residuals.res_warp_img(
src_zero_mask.float(), agg_field)
warped_zero_mask = (warped_zero_mask > 0.4).byte()
warped_zero_mask = helpers.crop(warped_zero_mask, self.pad)
cropped_out[warped_zero_mask] = 0
if self.seethrough_mask_layer is not None:
seethrough_mask = (self.seethrough_mask_layer.read(
bcube=self.bcube, mip=self.mip) != 0)
seethrough_bcube = self.bcube.translate(
z_offset=self.seethrough_offset)
seethrough_data = l.read(bcube=seethrough_bcube,
mip=self.mip)
cropped_out[seethrough_mask] = seethrough_data[
seethrough_mask]
seenthru = (cropped_out[seethrough_mask] != 0).sum()
corgie_logger.debug(f"Seenthrough {seenthru} pixels")
l.write(cropped_out, bcube=self.bcube, mip=self.mip)
for f in self.additional_fields:
# remove fields we added
self.src_stack.remove_layer(f.name)
def spoof_x_y_residual(self, x_d, y_d, mip, crop_amount=0):
x_res = crop(self.x_res_displacement(x_d, mip=mip), crop_amount)
y_res = crop(self.y_res_displacement(y_d, mip=mip), crop_amount)
result = np.stack((x_res, y_res), axis=2)
result = np.expand_dims(result, 0)
return result
def execute(self):
device = "cuda" if torch.cuda.is_available() else "cpu"
# Field padding
padded_bcube = self.bcube.uncrop(self.pad, self.mip)
for k, specs in enumerate(self.src_specs[::-1]):
src_z = specs["src_z"]
dst_z = self.bcube.z_range()[0]
corgie_logger.info(f"Load fields for {padded_bcube}")
# backwards compatible
if not isinstance(specs["src_field"], list):
specs["src_field"] = [specs["src_field"]]
mask_layer = self.src_layers[str(specs["src_mask"])]
field_ids = list(map(str, specs["src_field"]))
corgie_logger.info(f"field ids={field_ids}")
z_list = specs.get("src_field_z", [src_z] * len(field_ids))
fields = FieldSet([self.src_layers[n] for n in field_ids])
field = fields.read(
bcube=padded_bcube, z_list=z_list, mip=self.mip, device=device
)
bcube = padded_bcube.reset_coords(zs=src_z, ze=src_z + 1, in_place=False)
# Extend image/mask cutout to account for field spread
render_pad = int((field.max_vector() - field.min_vector()).max().ceil().tensor().item())
snap_factor = 2 ** (max(self.mip, mask_layer.data_mip) - self.mip)
render_pad = math.ceil(render_pad / snap_factor) * snap_factor
render_pad = min(render_pad, 4096) # Safety
render_bcube = bcube.uncrop(render_pad, self.mip)
corgie_logger.debug(f"render_pad: {render_pad}")
# Move image/mask cutout to account for field drift
img_trans = helpers.percentile_trans_adjuster(field)
mask_trans = img_trans.round_to_mip(self.mip, mask_layer.data_mip)
corgie_logger.debug(f"img_trans: {img_trans} | mask_trans: {mask_trans}")
img_bcube = render_bcube.translate(
x_offset=img_trans.y, y_offset=img_trans.x, mip=self.mip
)
mask_bcube = render_bcube.translate(
x_offset=mask_trans.y, y_offset=mask_trans.x, mip=self.mip
)
if render_pad > 0:
field = torch.nn.functional.pad(field, [render_pad, render_pad, render_pad, render_pad], mode='replicate')
corgie_logger.info(f"Load masks for {mask_bcube}")
mask_id = specs["mask_id"]
mask_layer.binarizer = helpers.Binarizer(["eq", mask_id])
mask = mask_layer.read(bcube=mask_bcube, mip=self.mip, device=device)
mask = residuals.res_warp_img(
mask.float(), field - mask_trans.to_tensor(device=field.device)
).tensor()
mask = (mask > 0.4).bool()
cropped_mask = helpers.crop(mask, self.pad + render_pad)
corgie_logger.info(f"Load image for {img_bcube}")
if cropped_mask.sum() == 0:
cropped_img = torch.zeros_like(cropped_mask, dtype=torch.float)
else:
img_layer = self.src_layers[str(specs["src_img"])]
img = img_layer.read(bcube=img_bcube, mip=self.mip, device=device)
img = residuals.res_warp_img(
img.float(), field - img_trans.to_tensor(device=field.device)
)
cropped_img = helpers.crop(img, self.pad + render_pad)
# write to composite image
if k == 0:
dst_img = cropped_img
dst_img[~cropped_mask] = 0
else:
dst_img[cropped_mask] = cropped_img[cropped_mask]
self.dst_layer.write(dst_img.cpu(), bcube=self.bcube, mip=self.mip)
