ConfocalLogic.initialize_image()

Complexity

Conditions

9

Size

Total Lines

130

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

# -*- coding: utf-8 -*-
    def initialize_image(self):
        """Initalization of the image.

        @return int: error code (0:OK, -1:error)
        """
        # x1: x-start-value, x2: x-end-value
        x1, x2 = self.image_x_range[0], self.image_x_range[1]
        # y1: x-start-value, y2: x-end-value
        y1, y2 = self.image_y_range[0], self.image_y_range[1]
        # z1: x-start-value, z2: x-end-value
        z1, z2 = self.image_z_range[0], self.image_z_range[1]

        # Checks if the x-start and x-end value are ok
        if x2 < x1:
            self.log.error(
                'x1 must be smaller than x2, but they are '
                '({0:.3f},{1:.3f}).'.format(x1, x2))
            return -1

        if self._zscan:
            if self.depth_img_is_xz:
                # creates an array of evenly spaced numbers over the interval
                # x1, x2 and the spacing is equal to xy_resolution
                self._X = np.linspace(x1, x2, self.xy_resolution)
            else:
                self._Y = np.linspace(y1, y2, self.xy_resolution)

            # Checks if the z-start and z-end value are ok
            if z2 < z1:
                self.log.error(
                    'z1 must be smaller than z2, but they are '
                    '({0:.3f},{1:.3f}).'.format(z1, z2))
                return -1
            # creates an array of evenly spaced numbers over the interval
            # z1, z2 and the spacing is equal to z_resolution
            self._Z = np.linspace(z1, z2, max(self.z_resolution, 2))
        else:
            # Checks if the y-start and y-end value are ok
            if y2 < y1:
                self.log.error(
                    'y1 must be smaller than y2, but they are '
                    '({0:.3f},{1:.3f}).'.format(y1, y2))
                return -1

            # prevents distorion of the image
            if (x2 - x1) >= (y2 - y1):
                self._X = np.linspace(x1, x2, max(self.xy_resolution, 2))
                self._Y = np.linspace(y1, y2, max(int(self.xy_resolution*(y2-y1)/(x2-x1)), 2))
            else:
                self._Y = np.linspace(y1, y2, max(self.xy_resolution, 2))
                self._X = np.linspace(x1, x2, max(int(self.xy_resolution*(x2-x1)/(y2-y1)), 2))

        self._XL = self._X
        self._YL = self._Y
        self._AL = np.zeros(self._XL.shape)

        # Arrays for retrace line
        self._return_XL = np.linspace(self._XL[-1], self._XL[0], self.return_slowness)
        self._return_AL = np.zeros(self._return_XL.shape)

        if self._zscan:
            self._image_vert_axis = self._Z
            # update image scan direction from setting
            self.depth_img_is_xz = self.depth_scan_dir_is_xz
            # depth scan is in xz plane
            if self.depth_img_is_xz:
                #self._image_horz_axis = self._X
                # creates an image where each pixel will be [x,y,z,counts]
                self.depth_image = np.zeros((
                        len(self._image_vert_axis),
                        len(self._X),
                        3 + len(self.get_scanner_count_channels())
                    ))

                self.depth_image[:, :, 0] = np.full(
                    (len(self._image_vert_axis), len(self._X)), self._XL)

                self.depth_image[:, :, 1] = self._current_y * np.ones(
                    (len(self._image_vert_axis), len(self._X)))

                z_value_matrix = np.full((len(self._X), len(self._image_vert_axis)), self._Z)
                self.depth_image[:, :, 2] = z_value_matrix.transpose()

            # depth scan is yz plane instead of xz plane
            else:
                #self._image_horz_axis = self._Y
                # creats an image where each pixel will be [x,y,z,counts]
                self.depth_image = np.zeros((
                        len(self._image_vert_axis),
                        len(self._Y),
                        3 + len(self.get_scanner_count_channels())
                    ))

                self.depth_image[:, :, 0] = self._current_x * np.ones(
                    (len(self._image_vert_axis), len(self._Y)))

                self.depth_image[:, :, 1] = np.full(
                    (len(self._image_vert_axis), len(self._Y)), self._YL)

                z_value_matrix = np.full((len(self._Y), len(self._image_vert_axis)), self._Z)
                self.depth_image[:, :, 2] = z_value_matrix.transpose()

                # now we are scanning along the y-axis, so we need a new return line along Y:
                self._return_YL = np.linspace(self._YL[-1], self._YL[0], self.return_slowness)
                self._return_AL = np.zeros(self._return_YL.shape)

            self.sigImageDepthInitialized.emit()

        # xy scan is in xy plane
        else:
            #self._image_horz_axis = self._X
            self._image_vert_axis = self._Y
            # creats an image where each pixel will be [x,y,z,counts]
            self.xy_image = np.zeros((
                    len(self._image_vert_axis),
                    len(self._X),
                    3 + len(self.get_scanner_count_channels())
                ))

            self.xy_image[:, :, 0] = np.full(
                (len(self._image_vert_axis), len(self._X)), self._XL)

            y_value_matrix = np.full((len(self._X), len(self._image_vert_axis)), self._Y)
            self.xy_image[:, :, 1] = y_value_matrix.transpose()

            self.xy_image[:, :, 2] = self._current_z * np.ones(
                (len(self._image_vert_axis), len(self._X)))

            self.sigImageXYInitialized.emit()
        return 0