Exemplo n.º 1
0
    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)
Exemplo n.º 2
0
    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)

        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):
        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)
Exemplo n.º 5
0
    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)
Exemplo n.º 6
0
    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)
Exemplo n.º 7
0
    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)
Exemplo n.º 8
0
import procspec

yaml_path = './specs/very_complex_processor.yaml'
proc = procspec.parse_proc(yaml_path=yaml_path, default_output='src_field')
import pdb
pdb.set_trace()