I have a purely aesthetic layer which has arrow symbols. Some aren't showing up right because the line is too small. I have selected maybe 50 records where I need to extend this line by a given number (ex. 2 meters). The extend line tool only extends lines to a specified intersection, so this tool isn't what I'm looking for.

I've tried editing the shape length field but it won't let me. Is there a simple way of doing this via field calculator or within the editor tool bar?

  • 1
    is the data in shape, gdb, fgdb? do you have basic, standard, advanced?
    – Brad Nesom
    Sep 16, 2013 at 18:17
  • Shape and advanced.
    – GISHuman
    Sep 16, 2013 at 20:17
  • Can I clarify, did you want to extend every feature in a polyline type shapefile, or just selected features?
    – user21951
    Sep 16, 2013 at 23:23
  • If you want to base your extension on the endpoint, you could go to the previous vertex and determine the slope between these two points. Then you can move the endpoint vertex your distance x based on said slope.
    – Paul
    Sep 16, 2013 at 23:55
  • @Paul, I'm writing a script to do just that, but it is a little more complex because you need to account for multi-part polylines. That is, you need to look at the start and end points and their neighbouring points for each part. I need to know that GISKid is interested in extending all features first though.
    – user21951
    Sep 17, 2013 at 0:21

3 Answers 3


Well I think I've gotten it down for lines of any vertex count. I haven't attempted multipart lines since I've never messed with it in arcpy. The coding was made a bit more difficult since there isn't write access to the lastPoint property for Geometry objects. Instead of using the slope (which was my initial thought), I used the code from this SO question. It doesn't rely on trigonometry, so it should be slightly more efficient. The following code works by moving the endpoint of a line to a new coordinate that lies along the prolongation of a line from the last two vertices. I tested it on a shapefile.

from math import hypot
import collections
from operator import add
import arcpy

layer = arcpy.GetParameterAsText(0)
distance = float(arcpy.GetParameterAsText(1))

#Computes new coordinates x3,y3 at a specified distance
#along the prolongation of the line from x1,y1 to x2,y2
def newcoord(coords, dist):
    (x1,y1),(x2,y2) = coords
    dx = x2 - x1
    dy = y2 - y1
    linelen = hypot(dx, dy)

    x3 = x2 + dx/linelen * dist
    y3 = y2 + dy/linelen * dist    
    return x3, y3

#accumulate([1,2,3,4,5]) --> 1 3 6 10 15
#Equivalent to itertools.accumulate() which isn't present in Python 2.7
def accumulate(iterable):    
    it = iter(iterable)
    total = next(it)
    yield total
    for element in it:
        total = add(total, element)
        yield total

#OID is needed to determine how to break up flat list of data by feature.
coordinates = [[row[0], row[1]] for row in
               arcpy.da.SearchCursor(layer, ["OID@", "SHAPE@XY"], explode_to_points=True)]

oid,vert = zip(*coordinates)

#Construct list of numbers that mark the start of a new feature class.
#This is created by counting OIDS and then accumulating the values.
vertcounts = list(accumulate(collections.Counter(oid).values()))

#Grab the last two vertices of each feature
lastpoint = [point for x,point in enumerate(vert) if x+1 in vertcounts or x+2 in vertcounts]

#Convert flat list of tuples to list of lists of tuples.
#Obtain list of tuples of new end coordinates.
newvert = [newcoord(y, distance) for y in zip(*[iter(lastpoint)]*2)]    

j = 0
with arcpy.da.UpdateCursor(layer, "SHAPE@XY", explode_to_points=True) as rows:
    for i,row in enumerate(rows):
        if i+1 in vertcounts:            
            row[0] = newvert[j]

I set the symbology to arrow at end for categories based on OID so that it will be easier to see the separation between features. Labeling was set to count vertices.enter image description here

  • This just helped me out a lot! However, this would be even more helpful in my particular situation if the distance parameter could be based on a field in the original line features. I have tried implementing this myself and know I would somehow have to iterate through the distances in the "newvert =" line but I'm having a hard time implementing it. If you were able to expand your code to do this I would be very grateful!
    – GeoJohn
    Aug 31, 2016 at 19:18
  • Don't forget to update your view, if you were running the script from within the Python console. My lines got really long after several "unsuccessful" tries.
    – EikeMike
    Apr 27, 2018 at 11:57

What if you make a selection of the lines you want to extend.
Buffer those lines by the amount of extension desired.
Convert that to a line fc.
Then extend to intersection.
You might have to break and delete the other end of the buffer to keep from overlapping the line in the middle. (I haven't seen a screenshot of what you have or want to do)
Or I think there is a tool in ettools (I am checking to see functionality and if it is free)
Didn't find anything useful in et tools I did find this thread for some (old) vb code. and a request for some python. you might follow it out and check the ideas.arcgis.com website.


Here's a method that works with multi-part polylines composed of any number of node points. It uses the open source GIS Whitebox GAT (http://www.uoguelph.ca/~hydrogeo/Whitebox/). Simply download Whitebox, open the Scripter (script icon on the toolbar), change the scripting language to Groovy, paste the following code in, and save it as 'ExtendVectorLines.groovy'. You can run it either from the Scripter or, the next time you launch Whitebox, it will appear as a plugin tool within the Vector Tools toolbox. It takes a shapefile and an extend distance as inputs. I'll include the tool in the next public release of Whitebox GAT.

 * Copyright (C) 2013 Dr. John Lindsay <[email protected]>
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

import java.awt.event.ActionListener
import java.awt.event.ActionEvent
import java.io.File
import java.util.concurrent.Future
import java.util.concurrent.*
import java.util.Date
import java.util.ArrayList
import whitebox.interfaces.WhiteboxPluginHost
import whitebox.geospatialfiles.ShapeFile
import whitebox.geospatialfiles.shapefile.*
import whitebox.ui.plugin_dialog.ScriptDialog
import whitebox.utilities.FileUtilities;
import groovy.transform.CompileStatic

// The following four variables are required for this 
// script to be integrated into the tool tree panel. 
// Comment them out if you want to remove the script.
def name = "ExtendVectorLines"
def descriptiveName = "Extend Vector Lines"
def description = "Extends vector polylines by a specified distance"
def toolboxes = ["VectorTools"]

public class ExtendVectorLines implements ActionListener {
private WhiteboxPluginHost pluginHost
private ScriptDialog sd;
private String descriptiveName

public ExtendVectorLines(WhiteboxPluginHost pluginHost, 
    String[] args, def descriptiveName) {
    this.pluginHost = pluginHost
    this.descriptiveName = descriptiveName

    if (args.length > 0) {
        final Runnable r = new Runnable() {
            public void run() {
        final Thread t = new Thread(r)
    } else {
        // Create a dialog for this tool to collect user-specified
        // tool parameters.
        sd = new ScriptDialog(pluginHost, descriptiveName, this)    

        // Specifying the help file will display the html help
        // file in the help pane. This file should be be located 
        // in the help directory and have the same name as the 
        // class, with an html extension.
        def helpFile = "ExtendVectorLines"

        // Specifying the source file allows the 'view code' 
        // button on the tool dialog to be displayed.
        def pathSep = File.separator
        def scriptFile = pluginHost.getResourcesDirectory() + "plugins" + pathSep + "Scripts" + pathSep + "ExtendVectorLines.groovy"

        // add some components to the dialog
        sd.addDialogFile("Input file", "Input Vector Polyline File:", "open", "Vector Files (*.shp), SHP", true, false)
        sd.addDialogFile("Output file", "Output Vector File:", "close", "Vector Files (*.shp), SHP", true, false)
        sd.addDialogDataInput("Distance:", "Enter a distance", "", true, false)

        // resize the dialog to the standard size and display it
        sd.setSize(800, 400)
        sd.visible = true

// The CompileStatic annotation can be used to significantly
// improve the performance of a Groovy script to nearly 
// that of native Java code.
private void execute(String[] args) {
    try {
        int i, f, progress, oldProgress, numPoints, numParts
        int part, startingPointInPart, endingPointInPart
        double x, y, x1, y1, x2, y2, xSt, ySt, xEnd, yEnd, slope;
        ShapefileRecordData recordData;
        double[][] geometry
        int[] partData
        if (args.length != 3) {
            pluginHost.showFeedback("Incorrect number of arguments given to tool.")
        // read the input parameters
        String inputFile = args[0]
        String outputFile = args[1]
        double d = Double.parseDouble(args[2]) // extended distance

        def input = new ShapeFile(inputFile)

        // make sure that input is of a POLYLINE base shapetype
        ShapeType shapeType = input.getShapeType()
        if (shapeType.getBaseType() != ShapeType.POLYLINE) {
            pluginHost.showFeedback("Input shapefile must be of a POLYLINE base shapetype.")

        int numFeatures = input.getNumberOfRecords()

        // set up the output files of the shapefile and the dbf
        ShapeFile output = new ShapeFile(outputFile, shapeType);
        FileUtilities.copyFile(new File(input.getDatabaseFile()), new File(output.getDatabaseFile()));

        int featureNum = 0;
        for (ShapeFileRecord record : input.records) {
            PointsList points = new PointsList();
            recordData = getXYFromShapefileRecord(record);
            geometry = recordData.getPoints();
            numPoints = geometry.length;
            partData = recordData.getParts();
            numParts = partData.length;

            for (part = 0; part < numParts; part++) {
                startingPointInPart = partData[part];
                if (part < numParts - 1) {
                    endingPointInPart = partData[part + 1] - 1;
                } else {
                    endingPointInPart = numPoints - 1;

                // new starting poing
                x1 = geometry[startingPointInPart][0]
                y1 = geometry[startingPointInPart][1]

                x2 = geometry[startingPointInPart + 1][0]
                y2 = geometry[startingPointInPart + 1][2]

                if (x1 - x2 != 0) {
                    slope = Math.atan2((y1 - y2) , (x1 - x2))
                    xSt = x1 + d * Math.cos(slope)
                    ySt = y1 + d * Math.sin(slope)
                } else {
                    xSt = x1
                    if (y2 > y1) {
                        ySt = y1 - d
                    } else {
                        ySt = y1 + d

                // new ending point
                x1 = geometry[endingPointInPart][0]
                y1 = geometry[endingPointInPart][3]

                x2 = geometry[endingPointInPart - 1][0]
                y2 = geometry[endingPointInPart - 1][4]

                if (x1 - x2 != 0) {
                    slope = Math.atan2((y1 - y2) , (x1 - x2))
                    xEnd = x1 + d * Math.cos(slope)
                    yEnd = y1 + d * Math.sin(slope)
                } else {
                    xEnd = x1
                    if (y2 < y1) {
                        yEnd = y1 - d
                    } else {
                        yEnd = y1 + d

                points.addPoint(xSt, ySt)
                for (i = startingPointInPart; i <= endingPointInPart; i++) {
                    x = geometry[i][0]
                    y = geometry[i][5]
                    points.addPoint(x, y)
                points.addPoint(xEnd, yEnd)


            for (part = 0; part < numParts; part++) {
                partData[part] += part * 2

            switch (shapeType) {
                case ShapeType.POLYLINE:
                    PolyLine line = new PolyLine(partData, points.getPointsArray());
                case ShapeType.POLYLINEZ:
                    PolyLineZ polyLineZ = (PolyLineZ)(record.getGeometry());
                    PolyLineZ linez = new PolyLineZ(partData, points.getPointsArray(), polyLineZ.getzArray(), polyLineZ.getmArray());
                case ShapeType.POLYLINEM:
                    PolyLineM polyLineM = (PolyLineM)(record.getGeometry());
                    PolyLineM linem = new PolyLineM(partData, points.getPointsArray(), polyLineM.getmArray());


        // display the output image

        // reset the progress bar
    } catch (Exception e) {

private ShapefileRecordData getXYFromShapefileRecord(ShapeFileRecord record) {
    int[] partData;
    double[][] points;
    ShapeType shapeType = record.getShapeType();
    switch (shapeType) {
        case ShapeType.POLYLINE:
            whitebox.geospatialfiles.shapefile.PolyLine recPolyLine =
                    (whitebox.geospatialfiles.shapefile.PolyLine) (record.getGeometry());
            points = recPolyLine.getPoints();
            partData = recPolyLine.getParts();
        case ShapeType.POLYLINEZ:
            PolyLineZ recPolyLineZ = (PolyLineZ) (record.getGeometry());
            points = recPolyLineZ.getPoints();
            partData = recPolyLineZ.getParts();
        case ShapeType.POLYLINEM:
            PolyLineM recPolyLineM = (PolyLineM) (record.getGeometry());
            points = recPolyLineM.getPoints();
            partData = recPolyLineM.getParts();
        default: // should never hit this.
            points = new double[1][2];
            points[1][0] = -1;
            points[1][6] = -1;
    ShapefileRecordData ret = new ShapefileRecordData(points, partData)
    return ret;

class ShapefileRecordData {
    private final double[][] points
    private final int[] parts
    ShapefileRecordData(double[][] points, int[] parts) {
        this.points = points
        this.parts = parts

    double[][] getPoints() {
        return points

    int[] getParts() {
        return parts


public void actionPerformed(ActionEvent event) {
    if (event.getActionCommand().equals("ok")) {
        final def args = sd.collectParameters()
        final Runnable r = new Runnable() {
            public void run() {
        final Thread t = new Thread(r)

if (args == null) {
pluginHost.showFeedback("Plugin arguments not set.")
} else {
def f = new ExtendVectorLines(pluginHost, args, descriptiveName)

enter image description here

enter image description here

  • I've just modified the code so that you can optionally choose to extend line starts, line ends, or both ends. Let me know if you're interested in the modified tool.
    – user21951
    Sep 17, 2013 at 17:39
  • Thanks for your help! I shall look into WhiteBox, I've never heard of it before. Cool to see that Guelph has such projects! I'm a UWindsor student myself.
    – GISHuman
    Sep 20, 2013 at 18:37
  • Windsor is an excellent place too! I've just released the latest version (3.0.5) and it includes the updated tool for extending lines. Let me know if you have any issues or feedback for me.
    – user21951
    Sep 20, 2013 at 18:42

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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