How to use simulated method in fMBT

Best Python code snippet using fMBT_python

data_augmentation.py

Source:data_augmentation.py

1import ants2import numpy as np3import random4def data_augmentation(input_image_list,5                      segmentation_image_list=None,6                      pointset_list=None,7                      number_of_simulations=10,8                      reference_image=None,9                      transform_type='affineAndDeformation',10                      noise_model='additivegaussian',11                      noise_parameters=(0.0, 0.05),12                      sd_simulated_bias_field=0.05,13                      sd_histogram_warping=0.05,14                      sd_affine=0.05,15                      output_numpy_file_prefix=None,16                      verbose=False17                     ):18    """19    Randomly transform image data.20    Given an input image list (possibly multi-modal) and an optional corresponding21    segmentation image list, this function will perform data augmentation with22    the following augmentation possibilities:23    * spatial transformations24    * added image noise25    * simulated bias field26    * histogram warping27    Arguments28    ---------29    input_image_list : list of lists of ANTsImages30        List of lists of input images to warp.  The internal list sets contain one31        or more images (per subject) which are assumed to be mutually aligned.  The32        outer list contains multiple subject lists which are randomly sampled to33        produce output image list.34    segmentation_image_list : list of ANTsImages35        List of segmentation images corresponding to the input image list (optional).36    pointset_list: list of pointsets37        Numpy arrays corresponding to the input image list (optional).  If using this38        option, the transform_type must be invertible.39    number_of_simulations : integer40        Number of simulated output image sets.  Default = 10.41    reference_image : ANTsImage42        Defines the spatial domain for all output images.  If one is not specified,43        we used the first image in the input image list.44    transform_type : string45        One of the following options: "translation", "rigid", "scaleShear", "affine",46        "deformation", "affineAndDeformation".47    noise_model : string48        'additivegaussian', 'saltandpepper', 'shot', or 'speckle'.49    noise_parameters : tuple or array or float50        'additivegaussian': (mean, standardDeviation)51        'saltandpepper': (probability, saltValue, pepperValue)52        'shot': scale53        'speckle': standardDeviation54        Note that the standard deviation, scale, and probability values are *max* values55        and are randomly selected in the range [0, noise_parameter].  Also, the "mean",56        "saltValue" and "pepperValue" are assumed to be in the intensity normalized range57        of [0, 1].58    sd_simulated_bias_field : float59        Characterize the standard deviation of the amplitude.60    sd_histogram_warping : float61        Determines the strength of the bias field.62    sd_affine : float63        Determines the amount of transformation based change.64    output_numpy_file_prefix : string65        Filename of output numpy array containing all the simulated images and segmentations.66    Returns67    -------68    list of lists of transformed images and/or outputs to a numpy array.69    Example70    -------71    >>> image1_list = list()72    >>> image1_list.append(ants.image_read(ants.get_ants_data("r16")))73    >>> image2_list = list()74    >>> image2_list.append(ants.image_read(ants.get_ants_data("r64")))75    >>> segmentation1 = ants.threshold_image(image1_list[0], "Otsu", 3)76    >>> segmentation2 = ants.threshold_image(image2_list[0], "Otsu", 3)77    >>> input_segmentations = list()78    >>> input_segmentations.append(segmentation1)79    >>> input_segmentations.append(segmentation2)80    >>> points1 = ants.get_centroids(segmentation1)[:,0:2]81    >>> points2 = ants.get_centroids(segmentation2)[:,0:2]82    >>> input_points = list()83    >>> input_points.append(points1)84    >>> input_points.append(points2)85    >>> input_images = list()86    >>> input_images.append(image1_list)87    >>> input_images.append(image2_list)88    >>> data = data_augmentation(input_images,89                                 input_segmentations,90                                 input_points,91                                 tranform_type="scaleShear")92    """93    from ..utilities import histogram_warp_image_intensities94    from ..utilities import simulate_bias_field95    from ..utilities import randomly_transform_image_data96    if reference_image is None:97        reference_image = input_image_list[0][0]98    number_of_modalities = len(input_image_list[0])99    # Set up numpy arrays if outputing to file.100    batch_X = None101    batch_Y = None102    batch_Y_points = None103    number_of_points = 0104    if pointset_list is not None:105        number_of_points = pointset_list[0].shape[0]106        batch_Y_points = np.zeros((number_of_simulations, number_of_points, reference_image.dimension))107    if output_numpy_file_prefix is not None:108        batch_X = np.zeros((number_of_simulations, *reference_image.shape, number_of_modalities))109        if segmentation_image_list is not None:110            batch_Y = np.zeros((number_of_simulations, *reference_image.shape))111    # Spatially transform input image data112    if verbose:113        print("Randomly spatially transforming the image data.")114    transform_augmentation = randomly_transform_image_data(reference_image,115        input_image_list=input_image_list,116        segmentation_image_list=segmentation_image_list,117        number_of_simulations=number_of_simulations,118        transform_type=transform_type,119        sd_affine=sd_affine,120        deformation_transform_type="bspline",121        number_of_random_points=1000,122        sd_noise=2.0,123        number_of_fitting_levels=4,124        mesh_size=1,125        sd_smoothing=4.0,126        input_image_interpolator='linear',127        segmentation_image_interpolator='nearestNeighbor')128    simulated_image_list = list()129    simulated_segmentation_image_list = list()130    simulated_pointset_list = list()131    for i in range(number_of_simulations):132        if verbose:133            print("Processing simulation " + str(i))134        segmentation = None135        if segmentation_image_list is not None:136            segmentation = transform_augmentation['simulated_segmentation_images'][i]137            simulated_segmentation_image_list.append(segmentation)138            if batch_Y is not None:139                if reference_image.dimension == 2:140                    batch_Y[i, :, :] = segmentation.numpy()141                else:142                    batch_Y[i, :, :, :] = segmentation.numpy()143        if pointset_list is not None:144            simulated_transform = transform_augmentation['simulated_transforms'][i]145            simulated_transform_inverse = ants.invert_ants_transform(simulated_transform)146            which_subject = transform_augmentation['which_subject'][i]147            simulated_points = np.zeros((number_of_points, reference_image.dimension))148            for j in range(number_of_points):149                simulated_points[j,:] = ants.apply_ants_transform_to_point(150                    simulated_transform_inverse, pointset_list[which_subject][j,:])151            simulated_pointset_list.append(simulated_points)152            if batch_Y_points is not None:153                batch_Y_points[i,:,:] = simulated_points154        simulated_local_image_list = list()155        for j in range(number_of_modalities):156            if verbose:157                print("    Modality " + str(j))158            image = transform_augmentation['simulated_images'][i][j]159            image_range = image.range()160            # Normalize to [0, 1] before applying augmentation161            if verbose:162                print("        Normalizing to [0, 1].")163            image = ants.iMath(image, "Normalize")164            # Noise165            if noise_model is not None:166                if verbose:167                    print("        Adding noise (" + noise_model + ").")168                if any( np.array(noise_parameters) > 0 ):169                   if noise_model.lower() == "additivegaussian":170                       parameters = (noise_parameters[0], random.uniform(0.0, noise_parameters[1]))171                       image = ants.add_noise_to_image(image,172                                                       noise_model="additivegaussian",173                                                       noise_parameters=parameters)174                   elif noise_model.lower() == "saltandpepper":175                       parameters = (random.uniform(0.0, noise_parameters[0]), noise_parameters[1], noise_parameters[2])176                       image = ants.add_noise_to_image(image,177                                                       noise_model="saltandpepper",178                                                       noise_parameters=parameters)179                   elif noise_model.lower() == "shot":180                       parameters = (random.uniform(0.0, noise_parameters[0]))181                       image = ants.add_noise_to_image(image,182                                                       noise_model="shot",183                                                       noise_parameters=parameters)184                   elif noise_model.lower() == "speckle":185                       parameters = (random.uniform(0.0, noise_parameters[0]))186                       image = ants.add_noise_to_image(image,187                                                       noise_model="speckle",188                                                       noise_parameters=parameters)189                   else:190                       raise ValueError("Unrecognized noise model.")191            # Simulated bias field192            if sd_simulated_bias_field > 0:193                if verbose:194                    print("        Adding simulated bias field.")195                bias_field = simulate_bias_field(image, sd_bias_field=sd_simulated_bias_field)196                image = image * (bias_field + 1)197            # Histogram intensity warping198            if sd_histogram_warping > 0:199                if verbose:200                    print("        Performing intensity histogram warping.")201                break_points = [0.2, 0.4, 0.6, 0.8]202                displacements = list()203                for b in range(len(break_points)):204                    displacements.append(random.gauss(0, sd_histogram_warping))205                image = histogram_warp_image_intensities(image,206                                                         break_points=break_points,207                                                         clamp_end_points=(False, False),208                                                         displacements=displacements)209            # Rescale to original intensity range210            if verbose:211                print("        Rescaling to original intensity range.")212            image = ants.iMath(image, "Normalize") * (image_range[1] - image_range[0]) + image_range[0]213            simulated_local_image_list.append(image)214            if batch_X is not None:215                if reference_image.dimension == 2:216                    batch_X[i, :, :, j] = image.numpy()217                else:218                    batch_X[i, :, :, :, j] = image.numpy()219        simulated_image_list.append(simulated_local_image_list)220    if batch_X is not None:221        if output_numpy_file_prefix is not None:222            if verbose:223                print("Writing images to numpy array.")224            np.save(output_numpy_file_prefix + "SimulatedImages.npy", batch_X)225    if batch_Y is not None:226        if output_numpy_file_prefix is not None:227            if verbose:228                print("Writing segmentation images to numpy array.")229            np.save(output_numpy_file_prefix + "SimulatedSegmentationImages.npy", batch_Y)230    if batch_Y_points is not None:231        if output_numpy_file_prefix is not None:232            if verbose:233                print("Writing segmentation images to numpy array.")234            np.save(output_numpy_file_prefix + "SimulatedPointsets.npy", batch_Y_points)235    if segmentation_image_list is None and pointset_list is None:236        return({'simulated_images' : simulated_image_list})237    elif segmentation_image_list is None:238        return({'simulated_images' : simulated_image_list,239                'simulated_pointset_list' : simulated_pointset_list})240    elif pointset_list is None:241        return({'simulated_images' : simulated_image_list,242                'simulated_segmentation_images' : simulated_segmentation_image_list})243    else:244        return({'simulated_images' : simulated_image_list,245                'simulated_segmentation_images' : simulated_segmentation_image_list,...

script_simulation.py

Source:script_simulation.py

1import functions_bit_computation as bit_computation2import functions_preprocessing as preprocessing3import functions_simulation as simulation4import functions_reconstruction as reconstruction5import functions_evaluation_index as evaluation_index6import numpy as np7from scipy import interpolate8# The script of the simulation9# Parameters of the reconstruction methods10rct = 60  # Attenuation parameter (sigma) of ED-SG11half_window = 10  # Half window size of SG filter12order = 3  # Three order polynomial for SG filter13window_size = half_window * 2 + 114hants_order = 15  # The number of harmonic waves15ws_lamda = 2.5  # smoothing parameter (lambda) for WS filter16method_list = ['original', 'sg', 'hants', 'bise', 'ed_sg', 'ws', 'mvi']17file_path = 'E:\\Envelope_Detection\\code\\'18# Input simulated real NDVI timeseries19simulated_actual = preprocessing.real_read_in(file_path + 'simulated_real.txt')20# Input the frequency distribution of the duration of the pixel state21probability_density = preprocessing.probability_density_read_in(file_path + 'probablity_density.txt')22# Input the frequency distribution of cloud covered NDVI values23cloud_density = preprocessing.cloud_density_read_in(file_path + 'cloudcover_ndvi.txt')24# repetition of the experiment25repetition = 126# compute the probability of the NDVI27integral_cloud = simulation.integral_cloud_ndvi(cloud_density)28overall_ac = np.zeros((len(method_list), repetition), float)29overall_variance = np.zeros((len(method_list), repetition), float)30ac_mean = np.zeros((len(method_list), 21, 21), float)  # record the mean of ac31# pixel_state includes "clear", "cloud cover" and "shadows and other states".32pixel_state = bit_computation.compute_pixel_state(file_path + 'cloud_timeseries.xls', file_path + 'cloud_timeseries.xls')33cloudcover_rate = pixel_state[1] / (pixel_state[1] + pixel_state[2])34shadow_rate = 1 - cloudcover_rate35for repeat in range(repetition):36    print('Repeation: ', repeat)37    ac_array = np.zeros((len(method_list), 21, 21), float)38    for i in range(21):39        for j in range(21):40            noise_random = 0.01 * i41            noise_subpixel = 0.01 * j42            ac_list = []43            # Creat simulated quality band44            simulated_quality = simulation.create_simulate_quality(probability_density, cloudcover_rate)45            # Add artificial noises46            simulated_observation = simulation.create_simulate_data\47                (simulated_actual, simulated_quality, integral_cloud, noise_random, noise_subpixel)48            # The performances of SG, HANTS and WS depend on the precision of the quality band. Here we randomly add49            # to the quality band to test the algorithms50            # pixel_state = bit_operation.compute_pixel_state(file_path + 'cloud_timeseries.xls', file_path + 'cloud_timeseries.xls')51            # cloudcover_rate = pixel_state[1] / (pixel_state[1] + pixel_state[2])52            # shadow_rate = 1 - cloudcover_rate53            # error_rate = 0.154            # for k in range(len(simulated_quality)):55            #     random_value = random.uniform(0, 1)56            #     if random_value <= 1 - error_rate:57            #         if simulated_quality[k] == 2:58            #             # simulated_quality[k] = 159            #             random_cloud = random.uniform(0, 1)60            #             if random_cloud < cloudcover_rate:61            #                 simulated_quality[k] = 0  # äºé®ç62            #             else:63            #                 simulated_quality[k] = 1  # äºé´å½±64            #         else:65            #             simulated_quality[k] = 266            # SG filtering, HANTS and WS need masked bad quality data based on simulated quality band67            value_effective = [simulated_observation[0]]68            t_effective = [1]69            for k in range(1, len(simulated_observation) - 1):70                if simulated_quality[k] == 2:71                    value_effective.append(simulated_observation[k])72                    t_effective.append(k + 1)73            value_effective.append(value_effective[-1])74            t_effective.append(len(simulated_observation))75            t_new = range(1, len(simulated_observation) + 1)76            linear_interpolate = interpolate.interp1d(t_effective, value_effective, kind="slinear")77            value_effective_interpolated = linear_interpolate(t_new)78            data_sg = reconstruction.sg_filtering(value_effective_interpolated, half_window, 3)79            #80            hants = reconstruction.hants(hants_order)81            data_hants = hants.hants(value_effective, t_effective, t_new)82            data_hants_sg = reconstruction.sg_filtering(data_hants, half_window, 3)83            data_hants = data_hants[half_window: len(data_hants) - half_window - 1]  # Unite the length of the data84            # data_idr = filtering_data.idr(simulated_observation)85            # data_idr_sg = filtering_data.sg_filtering(data_idr, half_window, 3)86            # data_idr = data_idr[half_window: len(data_idr) - half_window - 1]87            data_bise = reconstruction.bise(simulated_observation, 20, 0.1, 0.2)88            data_bise_sg = reconstruction.sg_filtering(data_bise, half_window, 3)89            data_bise = data_bise[half_window: len(data_bise) - half_window - 1]90            data_envelope_detection = reconstruction.envelope_detection(simulated_observation, t_new, rct)91            data_ed_sg = reconstruction.sg_filtering(data_envelope_detection, half_window, 3)92            data_envelope_detection = data_envelope_detection[93                                      half_window: len(data_envelope_detection) - half_window - 1]94            data_ws = reconstruction.ws(simulated_observation, simulated_quality, ws_lamda)95            data_ws_sg = reconstruction.sg_filtering(data_ws, half_window, order)96            data_ws = data_ws[half_window: len(data_ws) - half_window - 1]97            data_mvi = reconstruction.mvi(simulated_observation)98            data_mvi_sg = reconstruction.sg_filtering(data_mvi, half_window, 3)99            data_mvi = data_mvi[half_window: len(data_mvi) - half_window - 1]100            simulated_actual_show = simulated_actual[101                                      half_window: len(simulated_actual) - half_window - 1]102            ac_list.append(evaluation_index.ac(simulated_actual, simulated_observation))103            simulated_observation = simulated_observation[half_window: len(simulated_observation) - half_window - 1]104            ac_list.append(evaluation_index.ac(simulated_actual_show, data_sg))105            ac_list.append(evaluation_index.ac(simulated_actual_show, data_hants))106            # ac_list.append(evaluation_index.ac(simulated_actual_show, data_idr_sg))107            ac_list.append(evaluation_index.ac(simulated_actual_show, data_bise_sg))108            ac_list.append(evaluation_index.ac(simulated_actual_show, data_ed_sg))109            ac_list.append(evaluation_index.ac(simulated_actual_show, data_ws))110            ac_list.append(evaluation_index.ac(simulated_actual_show, data_mvi_sg))111            for k in range(len(ac_list)):112                ac_array[k, i, j] = ac_array[k, i, j] + ac_list[k]113            # simulated_observation = simulated_observation[half_window: len(simulated_observation) - half_window - 1]114            # data_output = np.array(simulated_observation)115            # data_output = np.row_stack((data_output, simulated_actual_show, data_sg))116            # print('sg')117            # postprocessing_data.plot_data(data_output)118            # #119            # data_output = np.array(simulated_observation)120            # data_output = np.row_stack((data_output, simulated_actual_show, data_hants, data_hants_sg))121            # print('hants')122            # postprocessing_data.plot_data(data_output)123            #124            # data_output = np.array(simulated_observation)125            # data_output = np.row_stack((data_output, simulated_actual_show, data_idr, data_idr_sg))126            # print('idr')127            # postprocessing_data.plot_data(data_output)128            #129            # data_output = np.array(simulated_observation)130            # data_output = np.row_stack((data_output, simulated_actual_show, data_bise, data_bise_sg))131            # print('bise')132            # postprocessing_data.plot_data(data_output)133            #134            # data_output = np.array(simulated_observation)135            # data_output = np.row_stack((data_output, simulated_actual_show, data_envelope_detection, data_ed_sg))136            # print('ed')137            # postprocessing_data.plot_data(data_output)138            #139            # data_output = np.array(simulated_observation)140            # data_output = np.row_stack((data_output, simulated_actual_show, data_ws, data_ws_sg))141            # print('ws')142            # postprocessing_data.plot_data(data_output)143            #144            # data_output = np.array(simulated_observation)145            # data_output = np.row_stack((data_output, simulated_actual_show, data_mvi, data_mvi_sg))146            # print('mvi')147            # postprocessing_data.plot_data(data_output)148    for i in range(len(method_list)):149        overall_ac[i][repeat] = ac_array[i].mean()150        overall_variance[i][repeat] = ac_array[i].var()151        ac_mean[i] = ac_mean[i] + ac_array[i]152ac_mean = ac_mean / repetition153for i in range(len(method_list)):154    print(method_list[i])155    print(overall_ac[i].mean())156    print(overall_variance[i].mean())157# Output AC array158ac_mean = ac_mean.tolist()159index = 0160for method in method_list:161    method_ac = ac_mean[index]162    ac_list = []163    # å°æ°æ®åç¬¦ä¸²å164    for item in method_ac:165        ac_string = ''166        for i in range(len(item)):167            ac_string = ac_string + ' ' + str(item[i])168        ac_list.append(ac_string)169    index += 1170    headline = "\t"171    output_name = file_path + method + '.txt'172    # with open(output_name, 'w') as file_handle: #ä»¥wæ ¼å¼æå¼ä¹åç´æ¥å³éä¼ä¼æ¸é¤ææ¬æä»¶åå®¹173    #     file_handle.close()174    with open(output_name, 'a') as file_handle:  # .txtå¯ä»¥ä¸èªå·±æ°å»º,ä»£ç ä¼èªå¨æ°å»º175        for line in ac_list:176            file_handle.write(line)177            file_handle.write('\n')...

test_simulator.py

Source:test_simulator.py

1"""2Tests for simulated data3"""4from __future__ import division5from __future__ import print_function6from __future__ import unicode_literals7import unittest8import datetime9import ga4gh.server.datamodel as datamodel10import ga4gh.server.datamodel.datasets as datasets11import ga4gh.server.datamodel.reads as reads12import ga4gh.server.datamodel.references as references13import ga4gh.server.datamodel.variants as variants14class TestSimulatedVariantSet(unittest.TestCase):15    """16    Test properties of the SimulatedVariantSet17    """18    def setUp(self):19        self.randomSeed = 020        self.numCalls = 221        # ensure variantDensity is >= 1 so we get deterministic behavoir22        self.variantDensity = 123        self.simulatedVariantSet = self._getSimulatedVariantSet()24        self.referenceName = 'ref'25        self.startPosition = 10026        self.endPosition = 10327        self.callSetIds = ['unused']28        self.bases = ["A", "C", "G", "T"]29    def _getSimulatedVariantSet(self):30        dataset = datasets.Dataset('dataset1')31        referenceSet = references.SimulatedReferenceSet("srs1")32        simulatedVariantSet = variants.SimulatedVariantSet(33            dataset, referenceSet, 'variantSet1', randomSeed=self.randomSeed,34            numCalls=self.numCalls, variantDensity=self.variantDensity)35        return simulatedVariantSet36    def _getSimulatedVariantsList(self, simulatedVariantSet=None):37        if simulatedVariantSet is None:38            simulatedVariantSet = self.simulatedVariantSet39        simulatedVariants = simulatedVariantSet.getVariants(40            self.referenceName, self.startPosition, self.endPosition,41            self.callSetIds)42        variantList = list(simulatedVariants)43        return variantList44    def testConstruction(self):45        # initializing SimulatedVariantSet should store values correctly46        self.assertEqual(47            self.randomSeed, self.simulatedVariantSet._randomSeed)48        self.assertEqual(49            self.numCalls, self.simulatedVariantSet._numCalls)50        self.assertEqual(51            self.variantDensity, self.simulatedVariantSet._variantDensity)52        self.assertEqual(53            self.simulatedVariantSet.getCreationTime(),54            self.simulatedVariantSet.getUpdatedTime())55    def testGetVariants(self):56        # calling getVariants should produce the expected results57        variantList = self._getSimulatedVariantsList()58        self.assertEqual(59            len(variantList), self.endPosition - self.startPosition)60        for offset, simulatedVariant in enumerate(variantList):61            start = self.startPosition + offset62            variantSetCompoundId = self.simulatedVariantSet.getCompoundId()63            variantCompoundId = datamodel.VariantCompoundId.parse(64                simulatedVariant.id)65            self.assertEqual(66                variantSetCompoundId.variant_set_id,67                self.simulatedVariantSet.getId())68            self.assertEqual(69                variantSetCompoundId.variant_set_id,70                variantCompoundId.variant_set_id)71            self.assertEqual(72                variantCompoundId.reference_name, self.referenceName)73            self.assertEqual(74                variantCompoundId.start, str(simulatedVariant.start))75            self.assertEqual(76                simulatedVariant.variant_set_id,77                self.simulatedVariantSet.getId())78            self.assertEqual(79                simulatedVariant.reference_name, self.referenceName)80            self.assertEqual(81                simulatedVariant.created, simulatedVariant.updated)82            self.assertEqual(simulatedVariant.start, start)83            self.assertEqual(simulatedVariant.end, start + 1)84            self.assertIn(simulatedVariant.reference_bases, self.bases)85            self.assertIn(86                simulatedVariant.alternate_bases[0], self.bases)87            self.assertEqual(len(simulatedVariant.calls), self.numCalls)88    def testConsistency(self):89        # two SimulatedBackend objects given the same parameters90        # should produce identical variant lists91        variantListOne = self._getSimulatedVariantsList()92        simulatedVariantSetTwo = self._getSimulatedVariantSet()93        variantListTwo = self._getSimulatedVariantsList(94            simulatedVariantSetTwo)95        self._assertEqualVariantLists(variantListOne, variantListTwo)96    def testSelfConsistent(self):97        # the same SimulatedBackend should produce identical98        # variant lists given the same parameters99        variantListOne = self._getSimulatedVariantsList()100        variantListTwo = self._getSimulatedVariantsList()101        self.assertEqual(variantListOne, variantListTwo)102    def _assertEqualVariantLists(self, variantListOne, variantListTwo):103        # need to make time-dependent fields equal before the comparison,104        # otherwise we're introducing a race condition105        timeDependentFields = ['created', 'updated']106        for variantList in (variantListOne, variantListTwo):107            for variant in variantList:108                for field in timeDependentFields:109                    setattr(variant, field, 0)110        self.assertEqual(variantListOne, variantListTwo)111class TestSimulatedVariantAnnotationSet(unittest.TestCase):112    def setUp(self):113        self.randomSeed = 1114        self.numCalls = 2115        # ensure variantDensity is >= 1 so we get deterministic behavoir116        self.variantDensity = 1117        self.referenceName = 'ref'118        self.startPosition = 100119        self.endPosition = 120120        self.callSetIds = ['unused']121        self.bases = ["A", "C", "G", "T"]122    def testCreation(self):123        dataset = datasets.Dataset('dataset1')124        referenceSet = references.SimulatedReferenceSet("srs1")125        localId = "variantAnnotationSetId"126        simulatedVariantSet = variants.SimulatedVariantSet(127            dataset, referenceSet, 'variantSet1', randomSeed=self.randomSeed,128            numCalls=self.numCalls, variantDensity=self.variantDensity)129        simulatedVariantAnnotationSet = variants.SimulatedVariantAnnotationSet(130            simulatedVariantSet, localId, self.randomSeed)131        annotations = simulatedVariantAnnotationSet.getVariantAnnotations(132                    self.referenceName, self.startPosition, self.endPosition)133        self.assertEquals(134            simulatedVariantSet.toProtocolElement().id,135            simulatedVariantAnnotationSet.toProtocolElement().variant_set_id,136            "Variant Set ID should match the annotation's variant set ID")137        for variant, ann in annotations:138            self.assertEquals(datetime.datetime.strptime(139                ann.created, "%Y-%m-%dT%H:%M:%S.%fZ").strftime(140                "%Y-%m-%dT%H:%M:%S.%fZ"), ann.created,141                "Expect time format to be in ISO8601")142            self.assertEqual(variant.id, ann.variant_id)143class TestSimulatedReadGroupSet(unittest.TestCase):144    """145    Test properties of the simulated ReadGroupSet146    """147    def testCreation(self):148        dataset = datasets.Dataset('dataset1')149        localId = "readGroupSetId"150        referenceSet = references.SimulatedReferenceSet("srs1")151        simulatedReadGroupSet = reads.SimulatedReadGroupSet(152            dataset, localId, referenceSet)153        for readGroup in simulatedReadGroupSet.getReadGroups():154            alignments = list(readGroup.getReadAlignments())...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.