4

I have several polygons, measured in acres. I'm looking to double the area, either by a buffer, or some other method. I will need to triple and quadruple in the end, as well.

I have tried to use Field Calculator in a new field, mathematically doubling the size, and using it as a field buffer, yet the resulting sizes are not double, but some other fraction thereof.

My map units are Decimal Degrees. I also have no problems opening a new project to accomplish this task, as this project is quite large and complicated.

  • 1
    Please include a tag for which software you are using, I'm aware that it's in the title but should also be in the tags. That's not as easy as it sounds. Buffer distance is in metres/feet/miles, not sq.m. It would be mathematically difficult to double their area as the polygons are bound to be irregular. – Michael Stimson May 27 '14 at 22:32
  • 2
    I would start by projecting your polygons into an equal-area coordinate system, rather than decimal degrees – Stephen Lead May 27 '14 at 22:56
  • I did that after I re-read my question. – Jennifer May 27 '14 at 23:12
  • ArcGIS has a tool called Increase Polygon Area, but there are catches. First, it's only included in the Production Mapping toolbox which you may not have depending on license level and extensions. Second, it iteratively creates a buffer until a minimum size is reached - so the result will actually be larger than 'double' or whatever. This assumes you want to 'grow' polygons and preserve shapes. Doubling area can be done other ways if proportionality isn't required. Can you clarify your end goal/use/restrictions? – Chris W May 28 '14 at 2:15
  • Thank you all for the help. This is an idea I may explore later. For now, I'm going with a different method, simply buffering each polygon by the feet on the side of an acre (209). This will add size to my treatment areas, expanding their boundaries. Not exactly what I want to do, but this is due by Friday. So, thanks again. – Jennifer May 28 '14 at 20:30
4

Here is a very ugly piece of code I've written quickly that will solve your problem. You will need to modify the source/output path and unique ObjectID field. You can run this script on any machine with ArcGIS 10.1+ installed with any ArcGIS license level. If you will use this tool often, you might consider wrapping it up into a script tool.

It takes an input feature class with polygon features and outputs the polygon feature class with buffered source polygons (each polygon's area is doubled). The input feature class should be stored in a projected coordinate system (I've tested my script on NAD_1927_StatePlane_Alabama_East_FIPS_0101, for instance). The main idea is that we are buffering a source polygon with an arbitrary distance and evaluate its resultant area. Depending on the ratio of the doubled area and the area we have so far, the buffering distance value gets bigger or smaller. The iteration go further until the doubled area and the area of buffered area will be identical.

Keep in mind that the execution time needed for the script to run will depend on the number of features in the source feature class and with what precision do you want your areas to match. E.g., the source feature's area is 450678.658967 sq.m. The double of this will be 901357.317934. When you buffer your source polygon, you have to decide what is acceptable - 901357 or 90135 or 901357.318 and so forth depending on what precision you want to achieve (decimals of meters or just 1 meter precision) and how do you round decimals.

Experiment with a feature class with just a couple of polygons. Please refer to the comments in the code for details.

import arcpy
arcpy.env.overwriteOutput = True
in_fc = r"C:\Program Files (x86)\ArcGIS\ArcTutor\BuildingaGeodatabase\Montgomery.gdb\Landbase\BlocksJustOnePoly"

search_cursor = arcpy.da.SearchCursor(in_fc,["SHAPE@AREA","OBJECTID_1"])
for source_feature in search_cursor:
    rounded_floated_result_area = 2 #any integer, empty variable
    doubled_area = 1 #any integer, empty variable
    rounded_doubled_area = 1 #any integer, empty variable
    iteration_counter = 0
    buffer_distance = 100 #any integer, a value to start buffering with,

    out_fc_temp = r"in_memory\bufferred" #temp fc that will hold just one buffered feature for each iteration

    while rounded_floated_result_area != rounded_doubled_area and iteration_counter < 20: #adjust the counter max value to limit the precision
        print "buffer: ", buffer_distance
        print "not rounded feature's area", source_feature[0]
        in_fc_onefeature = arcpy.MakeFeatureLayer_management(in_fc,"one_feature","""OBJECTID_1 = {0}""".format(source_feature[1]))
        arcpy.Buffer_analysis(in_fc_onefeature,out_fc_temp,"{0} Meters".format(buffer_distance))

        result_area = [row[0] for row in arcpy.da.SearchCursor(out_fc_temp,"SHAPE@AREA")] #starting working with the first buffered polygon in temp output fc
        floated_result_area = float(result_area[0])
        rounded_floated_result_area = round(floated_result_area,1) #adjust the value for rounding; large value - more precise results and longer execution time
        print "result area: ", rounded_floated_result_area
        doubled_area = source_feature[0]*3 #obtaining the doubled area of the source polygon; specify 2/3/4 etc
        rounded_doubled_area = round(doubled_area,1) #adjust the value for rounding; large value - more precise results and longer execution time
        print "doubled area: ", rounded_doubled_area

        if rounded_floated_result_area > doubled_area:
            buffer_distance = buffer_distance / (rounded_floated_result_area/doubled_area) #calculating coefficient for buffering
        else:
            buffer_distance = buffer_distance * (doubled_area/rounded_floated_result_area) #calculating coefficient for buffering
        iteration_counter += 1

    print "Number of iterations:", iteration_counter, "for feature ObjectID = {0}".format(source_feature[1])
    one_feature_output = r"C:\Program Files (x86)\ArcGIS\ArcTutor\BuildingaGeodatabase\Montgomery.gdb\Landbase\BlocksJustOnePoly_onefeature"
    arcpy.CopyFeatures_management(out_fc_temp,one_feature_output)
    final_enlarged_polys_fc = r"C:\Program Files (x86)\ArcGIS\ArcTutor\BuildingaGeodatabase\Montgomery.gdb\Landbase\BlocksJustOnePoly_appended"
    arcpy.Append_management(one_feature_output,final_enlarged_polys_fc,"NO_TEST")
1

Let us assume that you are in an equal area projection. You could then double the area using an affine transform.

using arcpy.da.searchcursor, you can read your polygons geometry (SHAPE@) and the coordinates of the centroid (SHAPE@XY), then you substract the coordinates of the centroid for each vertex, then you multiply by SQRT(2) (for doubling) and you add again the value of the centroid. You now have a new geometry with the same centroid but double the area, that you can store in a new feature class using arcpy.da.insertcursor.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.