def save(file_root, file_name, file_type=dic.FILE_TYPES['png'], image=dic.IMAGE_TYPES['Color']): """ Save image.| ----------- The function overwrites an existing file. ----------------------------------------------------------------------- Parameters ---------- file_root : QString Destination file root. file_name : QString Destination file name. file_type : QString, optional Destination file type. The default is dic.FILE_TYPES['png']. image : int, optional Index of image to save. The default is dic.IMAGE_TYPES['Color']. Returns ------- None. """ if not os.path.exists(file_root): os.makedirs(file_root) err_code = ax.LMK.iSaveImage(image, file_root + file_name + file_type) ax.error_code(err_code) # Check for error
def create_rect_image_size( image=dic.IMAGE_TYPES['Color'], region_id=dic.REGION_TYPES['Rectangle']['identifier'], region_points=dic.REGION_TYPES['Rectangle']['points']): """ Create a rectangular region the size of the whole image.| -------------------------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :image: int (default: IMAGE_TYPES['Color']) | Index of region list (same as image index) | Im is usually defined as 'Image', but we needed to call in Image() here :region_id: int (default: REGION_TYPES['Rectangle']['identifier']) | Type of region from REGION_TYPES{} :NumPoints: int (default: REGION_TYPES['Rectangle']['points']) | Number of points from REGION_TYPES{} Returns: :region_x_points: QStringList | List of x-points :region_y_points: QStringList | List of y-points """ [image_first_line, image_last_line, image_first_col, image_last_col, _] = im.get_size() x_coords = [image_first_col, image_last_col] y_coords = [image_first_line, image_last_line] [err_code, region_x_points, region_y_points] \ = ax.LMK.iCreateRegion(image, region_id, region_points, x_coords, y_coords) ax.error_code(err_code) # Check for error return region_x_points, region_y_points
def load(file_root, file_name, file_type=dic.FILE_TYPES['pcf'], image=dic.IMAGE_TYPES['Color']): """ Load image from .pcf.| --------------------- Loads a saved image from .pcf. Of course, the image needs to be saved first. ----------------------------------------------------------------------- Parameters ---------- file_root : QString Source file root. file_name : QString Source file name. file_type : QString, optional Source file type. .pus = Camera Image .pf = Luminance Image .pcf = Color Image The default is dic.FILE_TYPES['pcf']. image : int, optional Index of image to Load to. The default is dic.IMAGE_TYPES['Color']. Returns ------- None. """ err_code = ax.LMK.iLoadImage(image, file_root + file_name + file_type) ax.error_code(err_code) # Check for error
def create(image=dic.IMAGE_TYPES['Color'], region='Ellipse', x_coords=[1226, 500, 500], y_coords=[1026, 500, 500]): """ Create a region.| ---------------- Parameters ---------- image : TYPE, optional DESCRIPTION. The default is dic.IMAGE_TYPES['Color']. region : TYPE, optional DESCRIPTION. The default is 'Ellipse'. x_coords : TYPE, optional DESCRIPTION. The default is [1226, 500, 500]. y_coords : TYPE, optional DESCRIPTION. The default is [1026, 500, 500]. Returns ------- region_x_points : TYPE DESCRIPTION. region_y_points : TYPE DESCRIPTION. """ [err_code, region_x_points, region_y_points] \ = ax.LMK.iCreateRegion(image, dic.REGION_TYPES[region]['identifier'], dic.REGION_TYPES[region]['points'], x_coords, y_coords) ax.error_code(err_code) # Check for error return region_x_points, region_y_points
def create(image=0, name='Evaluation[1]'): """ Creates an image.| --------------------------- The image gets the size of the previous image (luminance image or previous evalutation image.) --------------------------------------------------------------------------- %timeit: 41.4 ms ± 41.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) Parameters ---------- LMK : Dispatch('lmk4.LMKAxServer') image : int, optional 0=Grey image, 1=Color image. The default is 0. name : QString, optional Wished image name. The default is 'Evaluation[1]'. Returns ------- index : int Index of the image created """ err_code, index = ax.LMK.iImageCreate(image, name) ax.error_code(err_code) return index
def get_target_properties(): """ Get properties of current target.| --------------------------------- The size of the target image is fixed. ----------------------------------------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') Returns: :target_type: int | 1 = Monochrome image | 2 = Color image | 3 = Display | in this case the type (monochrome or color) | is chosen automatically :target_height: int | Height in millimeters :target_width: int | Width in millimeters :target_lines: int | Number of image lines :target_columns: int | Number of image columns """ err_code, target_type, target_height, \ target_width, target_lines, \ target_columns = ax.LMK.iTIG_GetTargetProperties() ax.error_code(err_code) # Check for error return target_type, target_height, target_width, target_lines, target_columns
def set_value_unit(image=dic.IMAGE_TYPES['Color'], x_value='x', x_unit='pix', y_value='y', y_unit='pix', unit_area='pix^2'): """ Set the values and units of the axis.| ------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :image: int (default: IMAGE_TYPES['Color']) | Index of image :x_value: QString (default: 'x') | Value of X axis :x_unit: QString (default: 'pix') | Unit of X axis :y_value: QString (default: 'y') | Value of Y axis :y_unit: QString (default: 'pix') | Unit of Y axis :unit_area: QString (default: 'pix^2') | Unit of area """ err_code = ax.LMK.iCoordSystemSetValueUnit(image, x_value, x_unit, y_value, y_unit, unit_area) ax.error_code(err_code) # Check for error
def multi_pic(calibration_data_root, camera_no, autoscan=True, exposure_time=0.1, pic_count=1): """ MultiPic capture algorithm.| --------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :exposure_time: float (default: 0.1) | Exposure time to use :pic_count: int (default: 1) | Number of camera images """ if autoscan is True: _, filter_wheel_names = cam.get_filter_wheels(calibration_data_root, camera_no) exposure_times = cam.color_autoscan_time( filter_wheel_names) # [REQUIRED if wanting best exposure times] err_code = ax.LMK.iMultiPic2(max(exposure_times.items(), \ key=operator.itemgetter(1))[1], pic_count) else: err_code = ax.LMK.iMultiPic2(exposure_time, pic_count) ax.error_code(err_code) # Check for error
def get_program_info(): """ Get some information about program version and camera current used.| ------------------------------------------------------------------- %timeit: 144 µs ± 5.82 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each) Parameters ---------- LMK : Dispatch('lmk4.LMKAxServer') Returns ------- program_type : QString Type of program version program_version : QString Number of program version camera_type : QString Type of camera camera_no : QString Number of camera lens_no : QString Number of lens """ err_code, program_type, program_version, camera_type, camera_no, lens_no = \ ax.LMK.iGetProgramInfo() ax.error_code(err_code) # Check for error return program_type, program_version, camera_type, camera_no, lens_no
def get_value_unit(image=dic.IMAGE_TYPES['Color']): """ Get the values and units of the axis.| ------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :Image: int (default: IMAGE_TYPES['Color']) | Index of image Returns: :x_value: QString | Value of X axis :x_unit: QString | Unit of X axis :y_value: QString | Value of Y axis :y_unit: QString | Unit of Y axis :unit_area: QString | Unit of area """ [err_code, x_value, x_unit, y_value, y_unit, unit_area] = ax.LMK.iCoordSystemGetValueUnit(image) ax.error_code(err_code) # Check for error return x_value, x_unit, y_value, y_unit, unit_area
def create_statistic(statistic_type=dic.STATISTIC_TYPES['standardColor'], image=dic.IMAGE_TYPES['Color'], region=0, num_param=1, param_list=[1]): """ Create a new statistic.| ----------------------- Parameters: :lmk: | Dispatch('lmk4.LMKAxServer') :statistic_type: int (default: STATISTIC_TYPES['standardColor']) | Index of statistic type :image: int (default: Image = IMAGE_TYPES['Color']) | Image :region: int (default: 0) | Index of region in this image :num_param: int (default: 1) | Number of parameters for this statistic :param_list: QStringList """ [err_code, statistic] = ax.LMK.iCreateStatistic(statistic_type, image, region, num_param, param_list) ax.error_code(err_code) # Check for error return statistic
def open_camera(calibration_data_root, camera_no, lens_no): """ Set new camera calibration data.| -------------------------------- Parameters ---------- calibration_data_root : TYPE Path to the camera calibration data. More exactly spoken path to the lens sub directory. After calling this function the camera is completely reinitialized. If the string is empty a currently existing camera connection is finished.. camera_no : TYPE DESCRIPTION. lens_no : TYPE DESCRIPTION. Returns ------- None. """ err_code = ax.LMK.iSetNewCamera(calibration_data_root + '/' + camera_no + '/' + lens_no) ax.error_code(err_code) # Check for error
def get_pixel_color(image=dic.IMAGE_TYPES['Color'], line=500, column=500): """ Get a pixel value of a color image.| ----------------------------------- Parameters: :lmk: | Dispatch('lmk4.LMKAxServer') :image: int (default: IMAGE_TYPES['Color']) | Index of image :line: int (default: 500) | Line index :column: int (default: 500) | Column index Returns: | The function returns an error if the pixel position is outside or the image is a color image. :cie_r: float | Gets the red component of the pixel value :cie_g: float | Gets the green component of the pixel value :cie_b: float | Gets the blue component of the pixel value """ err_code, cie_r, cie_g, cie_b = ax.LMK.iImageGetPixelColor( image, line, column) ax.error_code(err_code) # Check for error return cie_r, cie_g, cie_b
def get_color_hist_vals(image=dic.IMAGE_TYPES['Color'], color_space=dic.COLOR_SPACES['XYZ']): """ Get the values of the histogram in a color image.| ------------------------------------------------- The color space is always RGB. ----------------------------------------------------------------------- Parameters: :lmk: | Dispatch('lmk4.LMKAxServer') :image: int (default: IMAGE_TYPES['Color']) | Index of object :color_space: int (default: COLOR_SPACES['XYZ']) | Wished color space from COLOR_SPACES{} Returns: :num_param: int | Number of values :x_coords: QStringList | x-coordinates :hist_values: QStringList | Histogram values """ err_code, num_param, x_coords, hist_values \ = ax.LMK.iGetColorHistogramValues(image, color_space) ax.error_code(err_code) # Check for error return num_param, x_coords, hist_values
def create_image(): """ Create template image with the adjusted parameters.| --------------------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') """ err_code = ax.LMK.iTIG_CreateImage() ax.error_code(err_code) # Check for error
def hide_dialog(): """ Make template image dialog invisible.| ------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') """ err_code = ax.LMK.iTIG_HideDialog() ax.error_code(err_code) # Check for error
def delete_image(): """ Remove template image from the display.| --------------------------------------- Template images can only be deleted from a display. If the target is an evaluation image, deletion is not possible. ----------------------------------------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') """ err_code = ax.LMK.iTIG_DeleteImage() ax.error_code(err_code) # Check for error
def set_grey_filter(grey_filter_index=0, grey_filter_selected=0): """ Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :grey_filter_index: int (default: 0) | Index of filter, indexes start from '0' :grey_filter_selected: int (default: 0) | 0 = deselect | 1 = select """ err_code = ax.LMK.iSetGreyFilter(grey_filter_index, grey_filter_selected) ax.error_code(err_code) # Check for error
def set_smear(smear=0): """ Set the parameter for smear correction.| --------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :smear: int (default: 0) | 0 = no smear | !0 = smear correction with at least 10 dark images captures | > 10 number of dark images """ err_code = ax.LMK.iSetSmear(smear) ax.error_code(err_code) # Check for error
def set_param_value(parameter, parameter_value): """ Set a certain parameter value.| ------------------------------ Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :parameter: QString | Name of parameter :parameter_value: float | Value of parameter (if bool, then 0 or 1) """ err_code = ax.LMK.iTIG_SetParameterValue(parameter, parameter_value) ax.error_code(err_code) # Check for error
def delete(image=dic.IMAGE_TYPES['Color'], index=0): """ Delete a region.| ---------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :image: int (default: IMAGE_TYPES['Color']) | Input: Index of region list (same as image index) :index: int (default: 0) | Index of region to delete """ err_code = ax.LMK.iDeleteRegion(image, index) ax.error_code(err_code) # Check for error
def set_focus_factor(focus_factor_no): """ Set a focus factor.| ------------------- See dialog "Camera|Recalibration" in LabSoft main menu. ----------------------------------------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :focus_factor: int | Index of focus factor """ err_code = ax.LMK.iSetFocusFactor(focus_factor_no) ax.error_code(err_code) # Check for error
def convert_cie_rgb(cie_r=255.0, cie_g=0.0, cie_b=0.0, r_ref=0.0, g_ref=0.0, b_ref=0.0, color_space=dic.COLOR_SPACES['XYZ']): """ Conversion of a color value from CIE-RGB to another color space.| ---------------------------------------------------------------- The color value is given in CIE-RGB and is converted into a color value in the target color space. If there is a reference color needed for this color space, the reference color is also in CIE-RGB. If there is no reference color needed, the three variables can be set to zero. The destination color space is given by the value of COLOR_SPACES{}. The three components of the destionation color are available in '_Out' after the function call returned. ----------------------------------------------------------------------- Parameters: :lmk: | Dispatch('lmk4.LMKAxServer') :cie_r: float (default: 255.0) | Red component of input color :cie_g: float (default: 0.0) | Green component of input color :cie_b: float (default: 0.0) | Blue component of input color :r_ref: float (default: 0.0) | Red component of reference color :g_ref: float (default: 0.0) | Green component of reference color :b_ref: float (default: 0.0) | Blue component of reference color :color_space: int (default: COLOR_SPACES['XYZ']) | Wished destination color space Returns: :output_color: array | Calculated color in an array shape of (1, 3) """ [err_code, out_i, out_ii, out_iii] = \ ax.LMK.iGetColor(cie_r, cie_g, cie_b, r_ref, g_ref, b_ref, color_space) ax.error_code(err_code) # Check for error # Place new values into an array output_color = np.array([[out_i], [out_ii], [out_iii]]) # Transpose array into (1, 3) shape output_color = output_color.T return output_color
def get_standard_statistic(statistic_type=dic.STATISTIC_TYPES['standardColor'], region=0, color_class=0): """ Determine parameter of the standard statistic.| ---------------------------------------------- Parameters: :lmk: | Dispatch('lmk4.LMKAxServer') :statistic_type: int (default: STATISTIC_TYPES['standardColor']) | Index of statistic type :region: int (default: 0) | Index of region in this image :color_class: int (default: 0) | Index of class or color: 0 = blue 1 = green 2 = red Returns: :area: float | Amount of pixels in area of statistic :stat_min: float | Minimum value :stat_max: float | Maximum value :stat_mean: float | Mean value :variance: float | Variance (...SD?) in values """ stats = {'Area': [], 'Min': [], 'Max': [], 'Mean': [], 'Variance': []} err_code, _, _, _, _, _ = ax.LMK.iGetStandardStatistic2( statistic_type, region, color_class) ax.error_code(err_code) # Check for error stats['Area'].append( ax.LMK.iGetStandardStatistic2(statistic_type, region, color_class)[1]) stats['Min'].append( ax.LMK.iGetStandardStatistic2(statistic_type, region, color_class)[2]) stats['Max'].append( ax.LMK.iGetStandardStatistic2(statistic_type, region, color_class)[3]) stats['Mean'].append( ax.LMK.iGetStandardStatistic2(statistic_type, region, color_class)[4]) stats['Variance'].append( ax.LMK.iGetStandardStatistic2(statistic_type, region, color_class)[5]) return stats
def set_target(display_id, display_name): """ Get current target for template image generation.| ------------------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :display_id: int | -1 = Use given image name | 0...N-1 = One of the connected displays :display_name: QString | Image name is only necessary if 'DisplayID' == -1 """ err_code = ax.LMK.iTIG_SetTarget(display_id, display_name) ax.error_code(err_code) # Check for error
def set_scattered_light(scattered_light=1): """ Use of scattered light correction.| ---------------------------------- Only usable if a parameter set is available in program. ----------------------------------------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :scattered_light: int (defualt: 1) | 1 = switch on scattered light correction | 0 = switch off scattered light correction """ err_code = ax.LMK.iSetScatteredLight(scattered_light) ax.error_code(err_code) # Check for error
def set_max_camera_time(max_time=5.0): """ Set the maximum possible exposure time.| --------------------------------------- The maximum values is of course restricted by camera properties. But you can use an even smaller time to avoid to long meausrement times. ----------------------------------------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :max_time: float (default: 5.0) | Wished value """ err_code = ax.LMK.iSetMaxCameraTime(max_time) ax.error_code(err_code) # Check for error
def get_number(): """ Returns the number of tables in the result tab widget.| ------------------------------------------------------ Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') Returns: :tables_no: int | Returns the number of tables """ err_code, tables_no = ax.LMK.iTableGetNumber() ax.error_code(err_code) # Check for error return tables_no
def set_autoscan(autoscan=1): """ Set use of autoscan algorithm.| ------------------------------ Determination of a good exposure time before the capturing algorithm. ----------------------------------------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :autoscan: int (default: 1) | 1 = Use autoscan 0 = Do not use autoscan """ err_code = ax.LMK.iSetAutoscan(autoscan) ax.error_code(err_code) # Check for error
def set_color_correction(col_corr_index=0, col_corr_selected=1): """ Selection of a color correction factor.| ------------------------------------------- Parameters: :LMK: | Dispatch('lmk4.LMKAxServer') :col_corr_index: int (default: 0) | List of factors :col_corr_selected: int (default: 1) | 0 = deselect | 1 = select """ err_code = ax.LMK.iSetColorCorr(col_corr_index, col_corr_selected) ax.error_code(err_code) # Check for error