Tôi quan tâm đến việc kiểm tra chiều rộng trung bình của một đa giác đại diện cho mặt đường. Tôi cũng có đường tâm là một vectơ (đôi khi không chính xác ở trung tâm). Trong ví dụ này, đường trung tâm có màu đỏ và đa giác có màu xanh:

Một cách tiếp cận mạnh mẽ mà tôi đã nghĩ đến, đó là đệm đường theo từng bước nhỏ, giao cắt đệm với lưới fishnet, giao giữa đa giác đường với lưới fishnet, tính diện tích giao nhau cho cả hai biện pháp giao nhau và tiếp tục thực hiện điều này cho đến khi lỗi nhỏ Đây là một cách tiếp cận thô thiển, và tôi tự hỏi liệu có một giải pháp thanh lịch hơn. Ngoài ra, điều này sẽ che giấu chiều rộng của một con đường lớn và một con đường nhỏ.

Tôi quan tâm đến giải pháp sử dụng phần mềm ArcGIS 10, PostGIS 2.0 hoặc QGIS. Tôi đã thấy câu hỏi này và đã tải xuống công cụ của Dan Patterson cho ArcGIS10, nhưng tôi không thể tính được những gì tôi muốn với nó.

Tôi vừa phát hiện ra công cụ Hình học giới hạn tối thiểu trong ArcGIS 10 cho phép tôi tạo ra các đa giác màu xanh lá cây sau đây:

Đây có vẻ là một giải pháp tốt cho những con đường đi theo lưới điện, nhưng sẽ không hoạt động khác, vì vậy tôi vẫn quan tâm đến bất kỳ đề xuất nào khác.

Một phần của vấn đề là tìm một định nghĩa phù hợp về "chiều rộng trung bình". Một số là tự nhiên nhưng sẽ khác nhau, ít nhất là một chút. Để đơn giản, hãy xem xét các định nghĩa dựa trên các thuộc tính dễ tính toán (ví dụ, sẽ loại trừ các định nghĩa dựa trên biến đổi trục trung gian hoặc trình tự bộ đệm).

Ví dụ, xem xét rằng trực giác nguyên mẫu của một đa giác có "chiều rộng" xác định là một bộ đệm nhỏ (nói về bán kính r với các đầu vuông) xung quanh một đa giác dài, khá thẳng (nói về độ dài L ). Chúng tôi nghĩ rằng 2r = w là chiều rộng của nó. Như vậy:

• Chu vi P của nó xấp xỉ bằng 2L + 2w;

• Diện tích A của nó xấp xỉ bằng w L.

Chiều rộng w và chiều dài L sau đó có thể được phục hồi dưới dạng gốc của bậc hai x ^ 2 - (P / 2) x + A; đặc biệt, chúng tôi có thể ước tính

• w = (P - Sqrt (P ^ 2 - 16A)) / 4 .

Khi bạn chắc chắn rằng đa giác thực sự dài và gầy, vì gần đúng hơn nữa, bạn có thể mất 2L + 2w để bằng 2L, từ đó

• w (thô sơ) = 2A / P

Sai số tương đối trong phép tính gần đúng này tỷ lệ thuận với w / L: đa giác càng mỏng, w / L càng gần 0 và phép tính gần đúng càng tốt.

Cách tiếp cận này không chỉ cực kỳ đơn giản (chỉ cần chia diện tích cho chu vi và nhân với 2), với bất kỳ công thức nào, nó không quan trọng cách đa giác được định hướng hoặc vị trí của nó (bởi vì các chuyển động Euclide này không thay đổi diện tích cũng như chu vi).

Bạn có thể cân nhắc sử dụng một trong hai công thức này để ước tính chiều rộng trung bình cho bất kỳ đa giác nào đại diện cho các đoạn đường. Lỗi bạn mắc phải trong ước tính ban đầu của w (với công thức bậc hai) xảy ra do khu vực A cũng bao gồm các nêm nhỏ ở mỗi lần uốn của đa tuyến gốc. Nếu tổng các góc uốn là t radian (đây là tổng độ cong tuyệt đối của đa tuyến), thì thực sự

• P = 2L + 2w + 2 Pi tw và

• A = L w + Pi tw ^ 2.

Cắm chúng vào giải pháp (công thức bậc hai) trước đó và đơn giản hóa. Khi khói tan , sự đóng góp từ thuật ngữ độ cong t đã biến mất! Những gì ban đầu trông giống như một xấp xỉ là hoàn toàn chính xác cho bộ đệm đa tuyến không tự giao nhau (với kết thúc bình phương). Đối với đa giác có chiều rộng thay đổi, do đó đây là định nghĩa hợp lý về chiều rộng trung bình.

Ở đây tôi chỉ ra một chút tối ưu hóa về giải pháp @whuber và tôi đang đặt vấn đề về "độ rộng bộ đệm", bởi vì nó rất hữu ích để tích hợp giải pháp cho một vấn đề tổng quát hơn: Có hàm nghịch đảo st_buffer, trả về ước tính độ rộng không?

CREATE FUNCTION buffer_width(
        -- rectangular strip mean width estimator
    p_len float,   -- len of the central line of g
    p_geom geometry, -- g
    p_btype varchar DEFAULT 'endcap=flat' -- st_buffer() parameter
) RETURNS float AS $f$
  DECLARE
    w_half float;
    w float;    
  BEGIN
         w_half := 0.25*ST_Area(p_geom)/p_len;
         w      := 0.50*ST_Area( ST_Buffer(p_geom,-w_half,p_btype) )/(p_len-2.0*w_half);
     RETURN w_half+w;
  END
$f$ LANGUAGE plpgsql IMMUTABLE;

Đối với vấn đề này, câu hỏi @celenius về chiều rộng đường , sw, giải pháp là

 sw = buffer_width(ST_Length(g1), g2)

trong đó sw"chiều rộng trung bình", g1đường trung tâm g2và đường phố g2là POLYGON . Tôi chỉ sử dụng thư viện tiêu chuẩn OGC, được thử nghiệm với PostGIS và giải quyết các ứng dụng thực tế nghiêm trọng khác có cùng chức năng đệm.

MÔ PHỎNG

A2là diện tích của g2, L1độ dài của đường trung tâm ( g1) của g2.

Giả sử rằng chúng ta có thể tạo g2bởi g2=ST_Buffer(g1,w)và đó g1là một đường thẳng, g2hình chữ nhật có chiều dài L1và chiều rộng 2*w, và

    A2 = L1*(2*w)   -->  w = 0.5*A2/L1

Nó không phải là cùng một công thức của @whuber, bởi vì đây wlà một nửa g2chiều rộng hình chữ nhật ( ). Nó là một công cụ ước tính tốt, nhưng như chúng ta có thể thấy bằng các thử nghiệm (bên dưới), không chính xác và hàm sử dụng nó như một đầu mối, để giảm g2diện tích và làm công cụ ước tính cuối cùng.

Ở đây chúng tôi không đánh giá bộ đệm với "endcap = vuông" hoặc "endcap = round", cần tổng A2 của một khu vực của bộ đệm điểm giống nhau w.

TÀI LIỆU THAM KHẢO: trong một diễn đàn tương tự năm 2005 , W. Huber giải thích những giải pháp tương tự và khác.

KIỂM TRA VÀ LÝ DO

Đối với các đường thẳng, kết quả, như mong đợi, là chính xác. Nhưng đối với hình học khác, kết quả có thể gây thất vọng. Lý do chính là, có lẽ, tất cả các mô hình là cho hình chữ nhật chính xác, hoặc cho hình học có thể xấp xỉ với một "hình chữ nhật dải". Ở đây một "bộ kiểm tra" để kiểm tra các giới hạn của phép tính gần đúng này (xem wfactortrong các kết quả ở trên).

 SELECT *, round(100.0*(w_estim-w)/w,1) as estim_perc_error
    FROM (
        SELECT btype, round(len,1) AS len, w, round(w/len,3) AS wfactor,
               round(  buffer_width(len, gbase, btype)  ,2) as w_estim ,
               round(  0.5*ST_Area(gbase)/len       ,2) as w_near
        FROM (
         SELECT
            *, st_length(g) AS len, ST_Buffer(g, w, btype) AS gbase
         FROM (
               -- SELECT ST_GeomFromText('LINESTRING(50 50,150 150)') AS g, -- straight
               SELECT ST_GeomFromText('LINESTRING(50 50,150 150,150 50,250 250)') AS g,
            unnest(array[1.0,10.0,20.0,50.0]) AS w
              ) AS t, 
             (SELECT unnest(array['endcap=flat','endcap=flat join=bevel']) AS btype
             ) AS t2
        ) as t3
    ) as t4;

CÁC KẾT QUẢ:

VỚI RECTANGLES (đường trung tâm là LINE STRAIGHT):

         btype          |  len  |  w   | wfactor | w_estim | w_near | estim_perc_error 
------------------------+-------+------+---------+---------+--------+------------------
 endcap=flat            | 141.4 |  1.0 |   0.007 |       1 |      1 |                0
 endcap=flat join=bevel | 141.4 |  1.0 |   0.007 |       1 |      1 |                0
 endcap=flat            | 141.4 | 10.0 |   0.071 |      10 |     10 |                0
 endcap=flat join=bevel | 141.4 | 10.0 |   0.071 |      10 |     10 |                0
 endcap=flat            | 141.4 | 20.0 |   0.141 |      20 |     20 |                0
 endcap=flat join=bevel | 141.4 | 20.0 |   0.141 |      20 |     20 |                0
 endcap=flat            | 141.4 | 50.0 |   0.354 |      50 |     50 |                0
 endcap=flat join=bevel | 141.4 | 50.0 |   0.354 |      50 |     50 |                0

VỚI GEOMETRIES KHÁC (đường trung tâm gấp):

         btype          | len |  w   | wfactor | w_estim | w_near | estim_perc_error 
 -----------------------+-----+------+---------+---------+--------+------------------
 endcap=flat            | 465 |  1.0 |   0.002 |       1 |      1 |                0
 endcap=flat join=bevel | 465 |  1.0 |   0.002 |       1 |   0.99 |                0
 endcap=flat            | 465 | 10.0 |   0.022 |    9.98 |   9.55 |             -0.2
 endcap=flat join=bevel | 465 | 10.0 |   0.022 |    9.88 |   9.35 |             -1.2
 endcap=flat            | 465 | 20.0 |   0.043 |   19.83 |  18.22 |             -0.9
 endcap=flat join=bevel | 465 | 20.0 |   0.043 |   19.33 |  17.39 |             -3.4
 endcap=flat            | 465 | 50.0 |   0.108 |   46.29 |  40.47 |             -7.4
 endcap=flat join=bevel | 465 | 50.0 |   0.108 |   41.76 |  36.65 |            -16.5

 wfactor= w/len
 w_near = 0.5*area/len
 w_estim is the proposed estimator, the buffer_width function.

Giới thiệu btypexem hướng dẫn ST_Buffer , với ilustratin tốt và LINESTRING được sử dụng ở đây.

KẾT LUẬN :

• công cụ ước tính w_estimluôn luôn tốt hơn w_near;
• cho g2hình học "gần hình chữ nhật" , ok, bất kỳwfactor
• đối với hình học khác (gần "dải hình chữ nhật"), sử dụng giới hạn wfactor=~0.01cho 1% lỗi trên w_estim. Lên đến wfactor này, sử dụng một công cụ ước tính khác.

Thận trọng và phòng ngừa

Tại sao xảy ra lỗi ước tính? Khi bạn sử dụng ST_Buffer(g,w), bạn mong đợi, theo "mô hình dải hình chữ nhật", rằng khu vực mới được thêm bởi bộ đệm có chiều rộng wkhoảng w*ST_Length(g)hoặc w*ST_Perimeter(g)... Khi không, thường là bởi các lớp phủ (xem các đường gấp) hoặc "kiểu dáng", là khi ước tính wsai số trung bình . Đây là thông điệp chính của các bài kiểm tra.

Để phát hiện vấn đề này tại bất kỳ vị vua đệm nào , hãy kiểm tra hành vi của việc tạo bộ đệm:

SELECT btype, w, round(100.0*(a1-len1*2.0*w)/a1)::varchar||'%' AS straight_error,  
                 round(100.0*(a2-len2*2.0*w)/a2)::varchar||'%' AS curve2_error,
                 round(100.0*(a3-len3*2.0*w)/a3)::varchar||'%' AS curve3_error
FROM (
 SELECT
    *, st_length(g1) AS len1, ST_Area(ST_Buffer(g1, w, btype)) AS a1,
    st_length(g2) AS len2, ST_Area(ST_Buffer(g2, w, btype)) AS a2,
    st_length(g3) AS len3, ST_Area(ST_Buffer(g3, w, btype)) AS a3
 FROM (
       SELECT ST_GeomFromText('LINESTRING(50 50,150 150)') AS g1, -- straight
              ST_GeomFromText('LINESTRING(50 50,150 150,150 50)') AS g2,
              ST_GeomFromText('LINESTRING(50 50,150 150,150 50,250 250)') AS g3,
              unnest(array[1.0,20.0,50.0]) AS w
      ) AS t, 
     (SELECT unnest(array['endcap=flat','endcap=flat join=bevel']) AS btype
     ) AS t2
) as t3;

CÁC KẾT QUẢ:

         btype          |  w   | straight_error | curve2_error | curve3_error 
------------------------+------+----------------+--------------+--------------
 endcap=flat            |  1.0 | 0%             | -0%          | -0%
 endcap=flat join=bevel |  1.0 | 0%             | -0%          | -1%
 endcap=flat            | 20.0 | 0%             | -5%          | -10%
 endcap=flat join=bevel | 20.0 | 0%             | -9%          | -15%
 endcap=flat            | 50.0 | 0%             | -14%         | -24%
 endcap=flat join=bevel | 50.0 | 0%             | -26%         | -36%

Nếu bạn có thể nối dữ liệu đa giác của mình với dữ liệu đường trung tâm của mình (bằng phương tiện không gian hoặc bảng), thì chỉ cần tính tổng các khu vực đa giác cho mỗi căn chỉnh đường tâm và chia cho chiều dài của đường tâm.

Tôi đã phát triển một công thức cho chiều rộng trung bình của đa giác và đưa nó vào hàm Python / ArcPy. Công thức của tôi bắt nguồn từ (nhưng thực chất là mở rộng) khái niệm đơn giản nhất về chiều rộng trung bình mà tôi đã thấy được thảo luận ở nơi khác; nghĩa là, đường kính của một vòng tròn có cùng diện tích với đa giác của bạn. Tuy nhiên, trong câu hỏi trên và trong dự án của tôi, tôi quan tâm nhiều hơn đến chiều rộng của trục hẹp nhất. Hơn nữa, tôi quan tâm đến chiều rộng trung bình cho các hình dạng không lồi, phức tạp.

Giải pháp của tôi là:

(perimeter / pi) * area / (perimeter**2 / (4*pi))
= 4 * area / perimeter

Đó là:

(Diameter of a circle with the same perimeter as the polygon) * Area / (Area of a circle with the same perimeter as the polygon)

Chức năng là:

def add_average_width(featureClass, averageWidthField='Width'):
    '''
    (str, [str]) -> str

    Calculate the average width of each feature in the feature class. The width
        is reported in units of the feature class' projected coordinate systems'
        linear unit.

    Returns the name of the field that is populated with the feature widths.
    '''
    import arcpy
    from math import pi

    # Add the width field, if necessary
    fns = [i.name.lower() for i in arcpy.ListFields(featureClass)]
    if averageWidthField.lower() not in fns:
        arcpy.AddField_management(featureClass, averageWidthField, 'DOUBLE')

    fnsCur = ['SHAPE@LENGTH', 'SHAPE@AREA', averageWidthField]
    with arcpy.da.UpdateCursor(featureClass, fnsCur) as cur:
        for row in cur:
            perim, area, width = row
            row[-1] = ((perim/pi) * area) / (perim**2 / (4 * pi))
            cur.updateRow(row)

    return averageWidthField

Đây là bản đồ được xuất với chiều rộng trung bình (và một số thuộc tính hình học khác để tham khảo) qua nhiều hình dạng khác nhau bằng cách sử dụng chức năng từ phía trên:

Một giải pháp khác với trục trung gian gần đúng:

1. Tính trục trung gian gần đúng của đa giác;
2. Lấy chiều dài của trục trung gian gần đúng;
3. Nhận khoảng cách từ cả hai đầu trục đến đường viền của đa giác;
4. Tổng chiều dài trục và khoảng cách từ bước 3 - đó là độ dài gần đúng của đa giác;
5. Bây giờ bạn có thể chia diện tích của đa giác theo chiều dài này và lấy chiều rộng trung bình của đa giác.

Kết quả chắc chắn sẽ sai đối với các đa giác trong đó trục trung gian gần đúng không phải là một đường liên tục duy nhất, vì vậy bạn có thể kiểm tra nó trước bước 1 và quay lại NULLhoặc một cái gì đó.

Dưới đây là ví dụ về PostgreSQL chức năng (lưu ý: bạn cần phải cài đặt PostGIS và postgis_sfcgal phần mở rộng):

CREATE FUNCTION ApproximatePolygonLength(geom geometry)
RETURNS float AS $$
    SELECT
        CASE
            /* in case when approximate medial axis is empty or simple line
             * return axis length
             */
            WHEN (ST_GeometryType(axis.axis) = 'ST_LineString' OR ST_IsEmpty(axis.axis))
                THEN axis_length.axis_length
                    + start_point_distance.start_point_distance
                    + end_point_distance.end_point_distance
            /* else geometry is too complex to define length */
            ELSE NULL
        END AS length
    FROM
        LATERAL (
            SELECT
                ST_MakeValid(geom) AS valid_geom
        ) AS valid_geom,
        LATERAL (
            SELECT
                /* `ST_LineMerge` returns:
                 *  - `GEOMETRYCOLLECTION EMPTY`, if `ST_ApproximateMedialAxis` is an empty line (i.e. for square);
                 *  - `LINESTRING ...`, if `ST_ApproximateMedialAxis` is a simple line;
                 *  - `MULTILINESTRING ...`, if `ST_ApproximateMedialAxis` is a complex line
                 *     that can not be merged to simple line. In this case we should return `NULL`.
                 */
                ST_LineMerge(
                    ST_ApproximateMedialAxis(
                        valid_geom.valid_geom
                    )
                ) AS axis
        ) AS axis,
        LATERAL (
            SELECT
                ST_Boundary(valid_geom.valid_geom) AS border
        ) AS border,
        LATERAL (
            SELECT
                ST_Length(axis.axis) AS axis_length
        ) AS axis_length,
        LATERAL (
            SELECT
                ST_IsClosed(axis.axis) AS axis_is_closed
        ) AS axis_is_closed,
        LATERAL (
            SELECT
                CASE WHEN axis_is_closed.axis_is_closed THEN 0
                ELSE
                    ST_Distance(
                        border.border,
                        CASE ST_GeometryType(axis.axis)
                            WHEN 'ST_LineString' THEN ST_StartPoint(axis.axis)
                            /* if approximate medial axis is empty (i.e. for square),
                             * get centroid of geometry
                             */
                            ELSE ST_Centroid(valid_geom.valid_geom)
                        END
                    )
                END AS start_point_distance
        ) AS start_point_distance,
        LATERAL (
            SELECT
                CASE WHEN axis_is_closed.axis_is_closed THEN 0
                ELSE
                    ST_Distance(
                        border.border,
                        CASE ST_GeometryType(axis.axis)
                            WHEN 'ST_LineString' THEN ST_EndPoint(axis.axis)
                            /* if approximate medial axis is empty (i.e. for square),
                             * get centroid of geometry
                             */
                            ELSE ST_Centroid(valid_geom.valid_geom)
                        END
                    )
                END AS end_point_distance
        ) AS end_point_distance;
$$ LANGUAGE SQL;

CREATE FUNCTION ApproximatePolygonWidth(geom geometry)
RETURNS float AS $$
    SELECT
        CASE
            WHEN length IS NULL THEN NULL
            ELSE area.area / length.length
        END AS width
    FROM
        (
            SELECT ApproximatePolygonLength(geom) AS length
        ) AS length,
        (
            SELECT
                ST_Area(
                    ST_MakeValid(geom)
                ) AS area
        ) AS area;
$$ LANGUAGE SQL;

Bất lợi:

Giải pháp này sẽ không hoạt động với các trường hợp khi đa giác gần như hình chữ nhật và con người có thể trực giác xác định chiều dài của nó nhưng trục trung gian gần đúng có các nhánh nhỏ gần cạnh và do đó thuật toán trả về Không có.

Thí dụ: