示例#1
0
    def test_point_data(self):
        arcpy.AddToolbox(self.toolbox_path)

        # Create an output location in scratch that uses a common prefix and random suffix
        # This helps prevent conflicts if things don't get cleaned up.
        temp_output = path.join(
            "%scratchGDB%",
            "test_point_data_{}".format(random.randint(0, 9999)))

        # Execute the tool
        arcpy.TestableBufferTool_TT(self.point_path, temp_output)

        # Build the location of the answer
        answer_output = path.join(self.database_path, "test_point_data_answer")

        # Compare the temp_output to the known answer.
        result = arcpy.FeatureCompare_management(
            in_base_features=answer_output,
            in_test_features=temp_output,
            sort_field=["Value"],
            continue_compare=True)

        # If it returns false, something has gone wrong, so fail the test.
        if result.getOutput(1) != 'true':
            print(result.getMessages())

        self.assertEqual(result.getOutput(1), 'true')

        # Clean up after ourselves
        arcpy.Delete_management(temp_output)
def compareGeometry():
    for key, value in fileMatches.iteritems():
        shapeOne = os.path.join(value[0], key)
        shapeTwo = os.path.join(value[1], key)

        fieldList = arcpy.ListFields(shapeOne)
        for field in fieldList:
            print("{0} is a type of {1} with a length of {2}".format(
                field.name, field.type, field.length))
        '''fieldList = arcpy.ListFields(shapeTwo)
        for field in fieldList:
            try:
                fieldName = str(field.name)
                #print("{0} is a type of {1} with a length of {2}".format(field.name, field.type, field.length))
                if fieldName not in fieldList:
                    fieldList.append(fieldName)
            except:
                pass'''
        #print shapeOne
        #print shapeTwo
        sort_field = 'FID'
        compare_type = "ALL"
        compare_result = arcpy.FeatureCompare_management(
            shapeOne, shapeTwo, sort_field, compare_type)

        print 'Compared results:', compare_result[0]
 def test_table_to_lineofbearing_desktop(self):
     '''Test Table To Line Of Bearing for ArcGIS Desktop'''
     runToolMessage = ".....TableToLineOfBearingTestCase.test_table_to_lineofbearing_desktop"
     arcpy.ImportToolbox(Configuration.military_DesktopToolboxPath, "mt")
     arcpy.AddMessage(runToolMessage)
     Configuration.Logger.info(runToolMessage)
     arcpy.TableToLineOfBearing_mt(self.inputTable, "DD_2", "x", "y",
                                   "DEGREES", "Orientation", "METERS",
                                   "Distance", self.outputLineOfBearing,
                                   "GEODESIC", None)
     self.assertTrue(arcpy.Exists(self.outputLineOfBearing),
                     "Output features do not exist or were not created")
     featureCount = int(
         arcpy.GetCount_management(self.outputLineOfBearing).getOutput(0))
     expectedFeatures = int(23)
     self.assertEqual(
         featureCount, expectedFeatures,
         "Expected %s features, but got %s" %
         (str(expectedFeatures), str(featureCount)))
     compareFeatures = arcpy.FeatureCompare_management(
         self.BaseFC, self.outputLineOfBearing, "OID")
     # identical = 'true' means that there are no differences between the base and the output feature class
     identical = compareFeatures.getOutput(1)
     self.assertEqual(identical, "true",
                      "Feature compare failed: \n %s" % arcpy.GetMessages())
     return
示例#4
0
    def assertFeatureClassEqual(self,
                                first,
                                second,
                                sort_field,
                                message=None,
                                compare_type=None,
                                ignore_options=None,
                                xy_tolerance=None,
                                m_tolerance=None,
                                z_tolerance=None,
                                attribute_tolerances=None,
                                omit_field=None):
        """
        Compares the second feature class to the first, and reports any issues.  Detailed issues are printed to the
        console if found.
        :param first:
        :param second:
        :param sort_field:
        :param message:
        :param compare_type:
        :param ignore_options:
        :param xy_tolerance:
        :param m_tolerance:
        :param z_tolerance:
        :param attribute_tolerances:
        :param omit_field:
        :return:
        """

        # Make a place to store the compare file
        compare_file = tempfile.mkstemp(".txt")
        os.close(compare_file[0])
        result = arcpy.FeatureCompare_management(
            first,
            second,
            sort_field,
            compare_type,
            ignore_options,
            xy_tolerance,
            m_tolerance,
            z_tolerance,
            attribute_tolerances,
            omit_field,
            continue_compare=True,
            out_compare_file=compare_file[1])
        if 'true' == result.getOutput(1):
            # delete the compare file
            os.remove(compare_file[1])
            return

        # read the compare file and print it out
        print(compare_file[1])
        with open(compare_file[1]) as f:
            [print(l.rstrip()) for l in f.readlines()]
        os.remove(compare_file[1])

        # set the assertion message.
        msg = message if message is not None else "Feature class {} is not equal to {}".format(
            second, first)
        raise AssertionError(msg)
示例#5
0
    def test_find_aoi(self):

        cmd_folder = os.path.realpath(
            os.path.abspath(os.path.split(getfile(currentframe()))[0]))

        testdata_folder = os.path.join(cmd_folder, 'test_data')
        input_folder = os.path.join(testdata_folder, 'input')
        reference_folder = os.path.join(testdata_folder, 'reference')

        parent = os.path.abspath(os.path.join(cmd_folder, os.pardir))

        if parent not in sys.path:
            sys.path.insert(0, parent)

        arcpy.env.overwriteOutput = True

        dem = os.path.join(input_folder, "dem.img")
        veg = os.path.join(input_folder, "vege.img")

        from bal import find_aoi

        extent_list = [
            'DEFAULT', 'MAXOF', 'MINOF',
            '343000 5850000 347000 5852000 343000 5850000 \
                       347000 5852000'
        ]

        mask_expect_list = [
            os.path.join(reference_folder, "expect_mask_others.shp"),
            os.path.join(reference_folder, "expect_mask_others.shp"),
            os.path.join(reference_folder, "expect_mask_others.shp"),
            os.path.join(reference_folder, "expect_mask.shp")
        ]

        index = 0
        for extent in extent_list:
            mask = find_aoi(extent, dem, veg)

            compare_result_mask = os.path.join(
                input_folder, "compare_mask_" + extent + ".txt")

            arcpy.FeatureCompare_management(mask, mask_expect_list[index],
                                            'Id', '', '', '', '', '', '', '',
                                            '', compare_result_mask)
            if '"true"' not in open(compare_result_mask).read():
                self.assertEqual(1, 1, 'No errors')
            else:
                self.assertEqual(1, 0, 'Has errors')

            os.remove(compare_result_mask)
            os.remove(
                os.path.join(input_folder, "compare_mask_" + extent + ".xml"))

            if arcpy.Exists(mask):
                arcpy.Delete_management(mask)

            index += 1
 def test_table_to_point_desktop_MGRS(self):
     '''Test Table To Point for ArcGIS Desktop_MGRS'''
     runToolMessage = ".....TableToPointTestCase.test_table_to_point_desktop_MGRS"
     arcpy.ImportToolbox(Configuration.military_DesktopToolboxPath, "mt")
     arcpy.AddMessage(runToolMessage)
     Configuration.Logger.info(runToolMessage)
     arcpy.TableToPoint_mt(self.inputSingleTable, "MGRS", "MGRS", None, self.outputPoints)
     self.assertTrue(arcpy.Exists(self.outputPoints), "Output features do not exist or were not created")
     pointCount = int(arcpy.GetCount_management(self.outputPoints).getOutput(0))
     expectedFeatures = int(288)
     self.assertEqual(pointCount, expectedFeatures, "Expected %s features, but got %s" % (str(expectedFeatures), str(pointCount)))
     compareFeatures = arcpy.FeatureCompare_management(self.BaseFC, self.outputPoints, "OID")         
     # identical = 'true' means that there are no differences between the baseFC and the output feature class
     identical = compareFeatures.getOutput(1)
     self.assertEqual(identical, "true", "Feature compare failed: \n %s" % arcpy.GetMessages())
     return
示例#7
0
 def test_table_to_ellipse_desktop_GEOREF(self):
     '''test_table_to_ellipse_desktop_GEOREF '''
     runToolMessage = ".....TableToEllipseTestCase.test_table_to_ellipse_desktop_GEOREF"
     arcpy.ImportToolbox(Configuration.military_DesktopToolboxPath, "mt")
     arcpy.AddMessage(runToolMessage)
     Configuration.Logger.info(runToolMessage)
     arcpy.TableToEllipse_mt(self.inputSingleTable, "GEOREF", "GEOREF", None, "Major", "Minor", "KILOMETERS", self.outputEllipses)
     self.assertTrue(arcpy.Exists(self.outputEllipses), "Output dataset does not exist.")
     ellipseCount = int(arcpy.GetCount_management(self.outputEllipses).getOutput(0))
     expectedFeatures = int(23)
     self.assertEqual(ellipseCount, expectedFeatures, "Expected %s features but got %s" % (str(expectedFeatures),str(ellipseCount)))
     compareFeatures = arcpy.FeatureCompare_management(self.baseFC, self.outputEllipses, "OBJECTID")
     # identical = 'true' means that there are no differences between the base and the output feature class
     identical = compareFeatures.getOutput(1)
     self.assertEqual(identical, "true", "Feature Compare failed: \n %s" % arcpy.GetMessages())
     return
示例#8
0
 def test_table_to_polyline_pro(self):
     '''Test Table To Polyline for ArcGIS Pro'''
     runToolMessage = ".....TableToPolylineTestCase.test_table_to_polyline_pro"
     arcpy.ImportToolbox(Configuration.military_ProToolboxPath, "mt")
     arcpy.AddMessage(runToolMessage)
     Configuration.Logger.info(runToolMessage)
     arcpy.TableToPolyline_mt(self.inputTable, "DD_2", "POINT_X", "POINT_Y", self.outputPolylines)
     self.assertTrue(arcpy.Exists(self.outputPolylines), "Output features do not exist or were not created")
     polylineCount = int(arcpy.GetCount_management(self.outputPolylines).getOutput(0))
     expectedFeatures = int(1)
     self.assertEqual(polylineCount, expectedFeatures, "Expected %s features, but got %s" % (str(expectedFeatures), str(polylineCount)))
     compareFeatures = arcpy.FeatureCompare_management(self.BaseFC, self.outputPolylines, "Shape_Length")
     # identical = 'true' means that there are no differences between the base and the output feature class
     identical = compareFeatures.getOutput(1)
     self.assertEqual(identical, "true", "Feature compare failed: \n %s" % arcpy.GetMessages())
     return
示例#9
0
    def test_get_footprint(self):

        cmd_folder = os.path.realpath(os.path.abspath(
                                      os.path.split(getfile(
                                      currentframe()))[0]))

        testdata_folder = os.path.join(cmd_folder, 'test_data')
        input_folder = os.path.join(testdata_folder, 'input')
        reference_folder = os.path.join(testdata_folder, 'reference')

        parent = os.path.abspath(os.path.join(cmd_folder, os.pardir))

        if parent not in sys.path:
            sys.path.insert(0, parent)

        arcpy.env.overwriteOutput = True

        veg = os.path.join(input_folder, "vege.img")

        from bal import get_footprint

        footprint_expect = os.path.join(reference_folder,
                                        "expect_footprint.shp")


        footprint = 'footprint.shp'
        get_footprint(veg, footprint)

        compare_result_footprint = os.path.join(input_folder,
                                           "compare_footprint.txt")

        arcpy.FeatureCompare_management(footprint, footprint_expect,
                                        'Id', '', '', '', '', '', '', '',
                                        '', compare_result_footprint)

        if '"true"' not in open(compare_result_footprint).read():
            self.assertEqual(1, 1, 'No errors')
        else:
            self.assertEqual(1, 0, 'Has errors')

        os.remove(compare_result_footprint)
        os.remove(os.path.join(input_folder, "compare_footprint.xml"))

        if arcpy.Exists(footprint):
            arcpy.Delete_management(footprint)
示例#10
0
 def test_findLocalPeaks(self):
     '''
     test_findLocalPeaks with input 10 peaks to find
     '''
     runToolMessage = ".....VisibilityUtilityTestCase.test_findLocalPeaks"
     arcpy.AddMessage(runToolMessage)
     Configuration.Logger.info(runToolMessage)
     resultPoints = os.path.join(Configuration.militaryScratchGDB,
                                 "findLocalPeaks")
     numPoints = 16
     resultPoints = VisibilityUtilities.findLocalPeaks(
         self.inputArea, numPoints, self.inputSurface, resultPoints)
     deleteIntermediateData.append(resultPoints)
     expectedLocalPeaks = os.path.join(Configuration.militaryResultsGDB,
                                       "ExpectedOutputFindLocalPeaks")
     compareResults = arcpy.FeatureCompare_management(
         resultPoints, expectedLocalPeaks, "OBJECTID").getOutput(1)
     self.assertEqual(compareResults, "true",
                      "Feature Compare failed: \n %s" % arcpy.GetMessages())
示例#11
0
 def test_hi_lowPointByArea_highest(self):
     '''
     test hi_lowPointByArea for MAXIMUM (highest) setting.
     '''
     runToolMessage = ".....VisibilityUtilityTestCase.test_hi_lowPointByArea_highest"
     arcpy.AddMessage(runToolMessage)
     Configuration.Logger.info(runToolMessage)
     hi_low_Switch = "MAXIMUM"
     resultPoints = os.path.join(Configuration.militaryScratchGDB,
                                 "highestPoints")
     resultPoints = VisibilityUtilities.hi_lowPointByArea(
         self.inputArea, self.inputSurface, hi_low_Switch, resultPoints)
     deleteIntermediateData.append(resultPoints)
     expectedHighest = os.path.join(Configuration.militaryResultsGDB,
                                    "ExpectedOutputHighestPt")
     compareResults = arcpy.FeatureCompare_management(
         resultPoints, expectedHighest, "OBJECTID").getOutput(1)
     self.assertEqual(compareResults, "true",
                      "Feature Compare failed: \n %s" % arcpy.GetMessages())
示例#12
0
    def test_get_extent_mask(self):

        cmd_folder = os.path.realpath(os.path.abspath(
                                      os.path.split(getfile(
                                      currentframe()))[0]))

        testdata_folder = os.path.join(cmd_folder, 'test_data')
        output_folder = os.path.join(testdata_folder, 'output')
        reference_folder = os.path.join(testdata_folder, 'reference')

        parent = os.path.abspath(os.path.join(cmd_folder, os.pardir))

        if parent not in sys.path:
            sys.path.insert(0, parent)

        arcpy.env.overwriteOutput = True

        mask_expect = os.path.join(reference_folder, "expect_extent_mask.shp")

        from bal import get_extent_mask

        extent = '343000 5850000 347000 5852000 343000 5850000 347000 5852000'

        mask = os.path.join(output_folder, "mask.shp")
        get_extent_mask(extent, mask)

        compare_result_mask = os.path.join(output_folder,
                                            "compare_mask.txt")

        arcpy.FeatureCompare_management(mask, mask_expect, 'Id', '', '', '', '',
                                       '', '', '', '', compare_result_mask)
        if '"true"' not in open(compare_result_mask).read():
            self.assertEqual(1, 1, 'No errors')
        else:
            self.assertEqual(1, 0, 'Has errors')

        if arcpy.Exists(mask):
            arcpy.Delete_management(mask)

        os.remove(compare_result_mask)
        os.remove(os.path.join(output_folder, "compare_mask.xml"))
示例#13
0
    def test_vector(self, ref_file, in_file, rep_file):
        """
        Logs differences in vector files.

        Parameters:
            ref_file -- reference vector file
            in_file  -- input vector file
            rep_file -- report file
        Return value:
            Logs resulting difference in vector files, error statement otherwise.
        """
        from pci.api import datasource as ds
        from pci.pcimod import pcimod
        from pci.exceptions import PCIException
        ##        from pci.his import *
        from pci.nspio import Report, enableDefaultReport
        from osgeo import gdal, ogr, osr
        ##        from gdalconst import *
        import numpy
        import arcpy

        try:
            logging.info('')
            logging.info('          Executing: EGSUtility.test_vector')
            logging.info('          Compare ref: ' + ref_file)
            logging.info('          Compare product: ' + in_file)
            logging.info('          Report file: ' + rep_file)
            if os.path.exists(rep_file):
                os.remove(rep_file)
            arcpy.FeatureCompare_management(ref_file, in_file, 'FID', 'ALL', '', '', 0, 0,\
                                          '', '', 'CONTINUE_COMPARE', rep_file)

            # open results file, output results to log file
            with open(rep_file) as infile:
                for line in infile:
                    logging.info(line)
                infile.close()

        except ValueError as e:
            self.error('test_vector(): {:s}'.format(e))
示例#14
0
        # Set local variables
        base_features = str(os.path.join(bseGdb, k))
        test_features = str(os.path.join(tgtGdb, k))
        sort_field = sortField
        compare_type = "All"
        ignore_option = "IGNORE_M;IGNORE_Z"
        xy_tolerance = "0.001 METERS"
        m_tolerance = 0
        z_tolerance = 0
        attribute_tolerance = "Shape_Length 0.001"
        omit_field = "#"
        continue_compare = "CONTINUE_COMPARE"

        # Process: FeatureCompare
        compare_result = arcpy.FeatureCompare_management(
            base_features, test_features, sort_field, compare_type,
            ignore_option, xy_tolerance, m_tolerance, z_tolerance,
            attribute_tolerance, omit_field, continue_compare, compare_file)
        fn.write("\n---------------\n")
        fn.write("For Feature class name :" + base_features + "\n")
        fn.write("\n---------------\n")
        fn.write(arcpy.GetMessages())
        fn.write("\n---------------\n")
        f = open(compare_file)
        f1 = open(outCsv, 'a')
        for x in f.readlines():
            ss = str(x)
            #print "going for Next value"
            #print ss
            checker1 = None
            #if 'RelationshipClass relationship class ID is different' in ss:
            #checker1 = True
示例#15
0
def compare_data(data):
    """TODO: add description"""
    max_severity = 0
    data_paths = [d['FILE PATH'] for d in data if os.path.exists(d['FILE PATH'])]
    if len(data_paths) == 1:
        return 1
    elif len(data_paths) == 0:
        return 1

    common_file_exts = ['.xyz', '.grd', '.txt', '.tab', '.ecw', '.lyr']
    common_raster_exts = ['.tif', '.jpg', '.img', '.png']
    common_gis_exts = ['.shp']
    common_cad_exts = ['.dxf']
    common_fds_exts = ['.sdc']
    common_workspace_exts = ['.gdb', '.mdb']

    ext = os.path.splitext(data_paths[0])[1].lower()
    if ext in common_file_exts:
        data_type = 'file'
    elif ext in common_raster_exts:
        data_type = 'rasterdataset'
    elif ext in common_gis_exts:
        data_type = 'shapefile'
    elif ext in common_cad_exts:
        data_type = 'caddrawingdataset'
    elif ext in common_workspace_exts:
        data_type = 'workspace'
    elif ext in common_fds_exts:
        data_type = 'featuredataset'
    elif ext in ['.mxd']:
        data_type = 'mapdocument'
    else:
        # Determine type of data
        data_type = arcpy.Describe(data_paths[0]).dataType

    # Create combinations of items
    combs = {}
    combs[data_paths[0]] = data_paths[1:]

    for item in combs.values()[0]:
        try:
            if data_type.lower() == 'shapefile':
                sort_field = get_sort_field([item, data_paths[0]])
                if sort_field:
                    result = arcpy.FeatureCompare_management(item, data_paths[0], sort_field, continue_compare=False)
                    max_severity = result.maxSeverity
                    if max_severity > 0:
                        break
            elif data_type.lower() == 'rasterdataset':
                # result = arcpy.RasterCompare_management(item, data_paths[0], continue_compare=False)
                # max_severity = result.maxSeverity
                max_serverity = raster_compare(item, data_paths[0])
                if max_severity > 0:
                    break
            elif data_type.lower() in ('arcinfotable', 'dbasetable'):
                sort_field = get_sort_field([item, data_paths[0]])
                if sort_field:
                    result = arcpy.TableCompare_management(item, data_paths[0], sort_field, continue_compare=False)
                    max_severity = result.maxSeverity
                    if max_severity > 0:
                        break
            elif data_type.lower() in ('file', 'textfile', 'prjfile', 'toolbox', 'layer'):
                if is_ascii(item):
                    result = arcpy.FileCompare_management(item, data_paths[0], "ASCII", False)
                    max_severity = result.maxSeverity
                    if max_severity > 0:
                        break
                else:
                    result = arcpy.FileCompare_management(item, data_paths[0], "BINARY", False)
                    max_severity = result.maxSeverity
                    if max_severity > 0:
                        break

            elif data_type.lower() == 'mapdocument':
                mxdA = arcpy.mapping.MapDocument(data_paths[0])
                data_framesA = arcpy.mapping.ListDataFrames(mxdA)
                mxdB = arcpy.mapping.MapDocument(item)
                data_framesB = arcpy.mapping.ListDataFrames(mxdB)

                # Compare dataframes
                if not sorted([dfA.name for dfA in data_framesA]) == sorted([dfB for dfB in data_framesB]):
                    max_severity = 1
                    break
                else:
                    # Compare layers in each dataframe
                    layersA = []
                    layersB = []
                    for dframe in data_framesA:
                        lyrs = arcpy.mapping.ListLayers(mxdA, data_frame=dframe)
                        if lyrs:
                            for lA in lyrs:
                                layersA.append(lA.name)
                    for dframe in data_framesB:
                        lyrs = arcpy.mapping.ListLayers(mxdB, data_frame=dframe)
                        if lyrs:
                            for lB in lyrs:
                                layersB.append(lB.name)
                    if not sorted(layersA) == sorted(layersB):
                        max_severity = 1
                        break

            elif data_type.lower() == 'workspace':
                max_severity = compare_geodatabases([data_paths[0], item])
                if max_severity > 0:
                    break

            elif data_type.lower() in ('featuredataset', 'caddrawingdataset'):
                arcpy.env.workspace = data_paths[0]
                fcsA = sorted([fc.lower() for fc in arcpy.ListFeatureClasses()])
                arcpy.env.workspace = item
                fcsB = sorted([fc.lower() for fc in arcpy.ListFeatureClasses()])
                if not len(fcsA) == len(fcsB):
                    max_severity = 1
                    break
                else:
                    for i, fc in enumerate(fcsA):
                        sort_field = get_sort_field([os.path.join(data_paths[0], fc), os.path.join(item, fcsB[i])])
                        if sort_field:
                            result = arcpy.FeatureCompare_management(os.path.join(data_paths[0], fc), os.path.join(item, fcsB[i]), sort_field, continue_compare=False)
                            max_severity = result.maxSeverity
                            if max_severity > 0:
                                break
        except arcpy.ExecuteError:
            status_writer.send_status(arcpy.GetMessages())
            max_severity = 0
            break
    return max_severity