Viktigt
Översättning är en gemenskapsinsats du kan gå med i. Den här sidan är för närvarande översatt till 99.93%.
24.1.23. Vektorgeometri
24.1.23.1. Lägg till geometriattribut
Beräknar geometriska egenskaper för objekten i ett vektorlager och inkluderar dem i utdatalagret.
Det genererar ett nytt vektorlager med samma innehåll som det ingående lagret, men med ytterligare attribut, som innehåller geometriska mätningar baserade på ett valt CRS.
De attribut som läggs till i tabellen beror på geometritypen och dimensionen för det ingående lagret:
för punkt lager: X (
xcoord
), Y (ycoord
), Z (zcoord
) koordinater och/eller M-värde (mvalue
)för line-lager:
längd
och, för geometrityperna LineString och CompoundCurve, egenskapensinuosity
och raksträcka (straightdis
)för polygon-lager: ”omkrets” och ”yta
Observera
Den här algoritmen använder ellipsoidbaserade mätningar och respekterar de aktuella ellipsoidinställningarna.
Standardmeny:
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Beräkna med hjälp av |
|
[uppräkning] Standard: 0 |
Beräkningsparametrar som ska användas för de geometriska egenskaperna. En av:
|
Lagt till geom-information |
|
[samma som inmatning] Standard: |
Ange utdatalagret (inmatningskopia med geometri). Ett av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Lagt till geom-information |
|
[samma som inmatning] |
Kopia av inmatningsvektorlagret med tillägg av geometriska fält |
Python-kod
Algoritm-ID: qgis:exportaddgeometrycolumns
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.2. Affin transform
Tillämpar en affin transformation på lagergeometrierna. Affina transformationer kan inkludera translation, skalning och rotation. Åtgärderna utförs i följande ordning: skala, rotation och translation.
Z- och M-värden (om sådana finns) kan översättas och skalas.

Fig. 24.59 Vektorpunktlager (gröna prickar) före (vänster) och efter (höger) en affin transformation (översättning).
Tillåter features in-place modification av punkt-, linje- och polygonfeatures
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Översättning (x-axeln) |
|
Standard: 0,0 |
Förskjutning som ska tillämpas på X-axeln. |
Översättning (y-axeln) |
|
Standard: 0,0 |
Förskjutning som ska tillämpas på Y-axeln. |
Translatering (z-axel) |
|
Standard: 0,0 |
Förskjutning som ska tillämpas på Z-axeln. |
Översättning (m-värden) |
|
Standard: 0,0 |
Offset som ska tillämpas på m-värden. |
Skalfaktor (x-axel) |
|
Standard: 1,0 |
Skalningsvärde (expansion eller kontraktion) som ska tillämpas på X-axeln. |
Skalfaktor (y-axel) |
|
Standard: 1,0 |
Skalningsvärde (expansion eller kontraktion) som ska tillämpas på Y-axeln. |
Skalfaktor (z-axel) |
|
Standard: 1,0 |
Skalningsvärde (expansion eller kontraktion) som ska tillämpas på Z-axeln. |
Skalfaktor (m-värden) |
|
Standard: 1,0 |
Skalningsvärde (expansion eller kontraktion) som ska tillämpas på m-värden. |
Rotation runt z-axeln (grader moturs) |
|
Standard: 0,0 |
Rotationens vinkel i grader. |
Transformerad |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Transformerad |
|
[samma som inmatning] |
Utgående (transformerat) vektorlager. |
Python-kod
Algoritm-ID: native:affinetransform
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.3. Sammanslagna
Tar ett vektor- eller tabellager och skapar ett nytt lager genom att aggregera funktioner baserat på ett group by
-uttryck.
Funktioner för vilka group by
-uttrycket returnerar samma värde grupperas tillsammans.
Det är möjligt att gruppera alla källfunktioner tillsammans med hjälp av ett konstant värde i parametern group by
, t.ex: NULL.
Det är också möjligt att gruppera funktioner efter flera fält med hjälp av Array-funktionen, t.ex: Array(”Fält1”, ”Fält2”).
Geometrier (om sådana finns) kombineras till en flerdelad geometri för varje grupp. Utdataattribut beräknas beroende på varje given aggregatdefinition.
Den här algoritmen gör det möjligt att använda standard aggregatsfunktioner i QGIS Expression-motorn.
Observera
Den här algoritmen använder ellipsoidbaserade mätningar och respekterar de aktuella ellipsoidinställningarna.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: vilken som helst] |
Ingångsvektorlager |
Gruppera efter uttryck |
|
[tabellfält: alla] Standard: ’NULL’ |
Välj grupperingsfält. Om NULL kommer alla funktioner att grupperas. |
Aggregat |
|
Konfigurationens id %1 finns redan i listan |
Lista över fältdefinitioner för utdatalagret. Exempel på en fältdefinition: {’aggregate’: ’sum’, ’delimiter’: ’,’, ’input’: ’ $area’, ’length’: 10, ’name’: ’totarea’, ’precision’: 0, ’typ’: 6} Som standard innehåller listan alla fält i inmatningslagret. I GUI kan du redigera dessa fält och deras definitioner, och du kan också: För vart och ett av de fält som du vill hämta information från måste du definiera följande:
|
Ladda fält från lagret |
Endast GUI |
[vektor: vilken som helst] |
Du kan ladda fält från ett annat lager och använda dem för aggregeringen |
Aggregerad |
|
[samma som inmatning] Standard: |
Ange det utgående (aggregerade) lagret One of:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Aggregerad |
|
[samma som inmatning] |
Multigeometriskt vektorlager med de aggregerade värdena |
Python-kod
Algoritm-ID: `native:aggregat`
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.4. Begränsning
Returnerar stängningen av den kombinatoriska gränsen för indatageometrierna (dvs. geometrins topologiska gräns).
Endast för polygon- och linjelager.
För polygongeometrier består gränsen av alla de linjer som utgör ringarna i polygonen.

Fig. 24.60 Gränser (svart streckad linje) för källans polygonlager
För linjegeometrier är gränserna deras ändpunkter.

Fig. 24.61 Gränsskikt (röda punkter) för linjer. I gult en vald funktion.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje, polygon] |
Vektorlager för linje- eller polygoninmatning |
Begränsning |
|
[vektor: punkt, linje] Standard: |
Ange det utgående (gräns)lagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Begränsning |
|
[vektor: punkt, linje] |
Gränser från inmatningslagret (punkt för linje och linje för polygon) |
Python-kod
Algoritm-ID: native:boundary
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.5. Begränsande boxar
Beräknar begränsningsrutan (envelope) för varje objekt i ett inmatningslager. Polygon- och linjegeometrier stöds.

Fig. 24.62 Svarta linjer representerar de avgränsande boxarna för varje polygonfunktion
Tillåter features in-place modification av polygonfeatures
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje, polygon] |
Vektorlager för linje- eller polygoninmatning |
Begränsningar |
|
[vektor: polygon] Standard: |
Ange utdatalagret (bounding box). Ett av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Begränsningar |
|
[vektor: polygon] |
Inmatningslagrets avgränsande rutor. Förutom input-attributen innehåller output-lagret också följande fält: |
Python-kod
Algoritm-ID: `native:boundingboxes
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.6. Buffra
Beräknar ett buffertområde för alla funktioner i ett inmatningslager med hjälp av ett fast eller datadefinierat avstånd.
Det är möjligt att använda ett negativt avstånd för polygoninmatningslager. I detta fall kommer bufferten att resultera i en mindre polygon (setback).

Fig. 24.63 Buffert (i gult) för punkter, linjer, polygoner med positiv buffert och polygoner med negativ buffert
Tillåter features in-place modification av polygonfeatures
Standardmeny:
Varning
Den här algoritmen kan ta bort befintliga primärnycklar eller FID-värden och återskapa dem i utdatalagren, beroende på indataparametrarna.
Se även
Buffert med variabelt avstånd, Buffert med flera ringar (konstant avstånd), Buffert med variabel bredd (av M-värde)
Parametrar
Grundläggande parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Avstånd inom vilket ett objekt kommer att snäppa till dina placerade stödlinjer. Efter att du har ställt in detta måste du starta om Scribus för att ställa in denna inställning. |
|
Standard: 10.0 |
Buffertavstånd (från gränsen för varje funktion). Du kan använda knappen Data Defined (Datadefinierad) till höger för att välja ett fält från vilket radien ska beräknas. På så sätt kan du ha olika radier för varje funktion. |
Segment |
|
[numerisk: heltal] Standard: 5 |
Styr antalet linjesegment som ska användas för att approximera en kvartscirkel när man skapar avrundade offsets. |
Typ av slutlock |
|
[uppräkning] Standard: 0 |
Styr hur radavslut ska hanteras i bufferten. Ett av följande:
![]() Fig. 24.64 Runda, platta och fyrkantiga lock |
Join style |
|
[uppräkning] Standard: 0 |
Anger om runda, geringade eller avfasade skarvar ska användas vid förskjutning av hörn i en linje. Alternativen är:
![]() Fig. 24.65 Runda, geringade och fasade fogningsstilar |
Mitergräns |
|
[numerisk: dubbel] Standard: 2,0 |
Ställer in det maximala avståndet från offsetgeometrin som ska användas när man skapar en geringad fog som en faktor av offsetavståndet (gäller endast för geringade fogstilar). Minsta värde: 1.0 ![]() Fig. 24.66 En 10 m buffert med en gräns på 2 och en 10 m buffert med en gräns på 1 |
Lös upp resultatet |
|
[boolean] Standard: Falsk |
Lös upp den slutliga bufferten. Om ![]() Fig. 24.67 Standard (tre endelade inslag - vänster), upplöst (1 flerdelat inslag med 2 delar - höger) |
Buffrad |
|
[vektor: polygon] Standard: |
Ange utdatalagret (buffert). En av:
Här kan du också ändra filkodningen. |
Avancerade parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Håll isär olika funktioner |
|
[boolean] Standard: Falsk |
Om ![]() Fig. 24.68 Resultat i 2 enstaka delar |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Buffrad |
|
[vektor: polygon] |
Utgående (buffert) polygonlager |
Python-kod
Algoritm-ID: native:buffer
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.7. Centroider
Skapar ett nytt punktlager med punkter som representerar mittpunkterna i geometrierna i inmatningslagret.
Centroiden är en enda punkt som representerar barycentrum (av alla delar) av objektet, så den kan ligga utanför objektets gränser. Men det kan också vara en punkt på varje del av objektet.
Attributen för punkterna i det utgående lagret är desamma som för de ursprungliga funktionerna.

Fig. 24.69 De röda stjärnorna representerar centroiderna för funktionerna i inmatningslagret.
Tillåter features in-place modification av punktfeatures
Standardmeny:
Varning
Den här algoritmen kan ta bort befintliga primärnycklar eller FID-värden och återskapa dem i utdatalagren, beroende på indataparametrarna.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Skapa centroid för varje del |
|
Standard: Falsk |
Om True (markerat) skapas en centroid för varje del av geometrin |
Centroider |
|
[vektor: punkt] Standard: |
Ange det utgående lagret (centroid). En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Centroider |
|
[vektor: punkt] |
Utgångspunkt vektorlager (centroider) |
Python-kod
Algoritm-ID: native:centroids
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.8. Kontrollera giltighet
Utför en validitetskontroll av geometrierna i ett vektorlager.
Geometrierna klassificeras i tre grupper (giltig, ogiltig och fel) och för varje grupp genereras ett vektorlager med dess egenskaper:
Lagret Valid output innehåller endast de giltiga funktionerna (utan topologiska fel).
Lagret Invalid output innehåller alla ogiltiga funktioner som algoritmen har hittat.
Lagret Error output är ett punktlager som pekar på var de ogiltiga funktionerna hittades.
Attributtabellerna för de genererade lagren kommer att innehålla viss ytterligare information (”message” för error-lagret, ”FID” och ”_errors” för invalid-lagret och endast ”FID” för valid-lagret):
Attributtabellen för varje genererat vektorlager kommer att innehålla ytterligare information (antal fel som hittats och typ av fel):

Fig. 24.70 Vänster: inmatningslagret. Höger: det giltiga lagret (grönt), det ogiltiga lagret (orange)
Standardmeny:
Se även
Fixa geometrier och kärntillägget Tillägget Geometrikontroll, Validera täckning
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Metod |
|
[uppräkning] Standard: 2 |
Metod som ska användas för att kontrollera giltigheten. Alternativ:
|
Ignore ring self intersection |
|
[boolean] Standard: Falsk |
Ignorera självskärande ringar när du kontrollerar giltigheten. |
Giltig utdata |
|
[samma som inmatning] Standard: |
Ange det vektorlager som ska innehålla en kopia av de giltiga egenskaperna i källlagret. One of:
Här kan du också ändra filkodningen. |
Ogiltig utdata |
|
[samma som inmatning] Standard: |
Vektorlager som innehåller en kopia av de ogiltiga funktionerna i källlagret med fältet
Här kan du också ändra filkodningen. |
Felutmatning |
|
[vektor: punkt] Standard: |
Punktlager av den exakta positionen för de validitetsproblem som upptäckts med fältet
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Antal fel |
|
[numerisk: heltal] |
Antalet geometrier som orsakade fel. |
Felutmatning |
|
[vektor: punkt] |
Punktlager med den exakta positionen för de validitetsproblem som upptäckts med fältet |
Antal ogiltiga funktioner |
|
[numerisk: heltal] |
Antalet ogiltiga geometrier. |
Ogiltig utdata |
|
[samma som inmatning] |
Vektorlager som innehåller en kopia av de ogiltiga funktionerna i källlagret med fältet |
Antal giltiga funktioner |
|
[numerisk: heltal] |
Antalet giltiga geometrier. |
Giltig utdata |
|
[samma som inmatning] |
Vektorlager som innehåller en kopia av de giltiga egenskaperna i källlagret. |
Python-kod
Algoritm-ID: qgis:checkvalidity
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
Olika typer av felmeddelanden och deras innebörd
Geometrisammanhang |
GEOS-validering och felmeddelande |
QGIS-validering och felmeddelande |
---|---|---|
På varandra följande punkter på en linje har samma koordinater ![]() |
||
Delar av en linje skär varandra ![]() |
||
Polygongeometri rör vid sig själv och genererar en ring ![]() |
||
Två ringar (yttre eller inre) i en polygongeometri är identiska ![]() |
||
Geometrin rör vid sig själv ![]() |
||
En polygongeometri ligger ovanpå en annan polygongeometri ![]() |
||
En del av en multipolygongeometri ligger inom ett hål i en multipolygongeometri ![]() |
||
Punktgeometrin har inte ett korrekt koordinatpar. Koordinatparet innehåller inte ett latitudvärde och ett longitudvärde i nämnd ordning. |
24.1.23.9. Samla in geometrier
Tar ett vektorlager och samlar dess geometrier till nya flerdelade geometrier.
Ett eller flera attribut kan anges för att endast samla in geometrier som tillhör samma klass (som har samma värde för de angivna attributen), alternativt kan alla geometrier samlas in.
Alla utdatageometrier konverteras till multigeometrier, även de som bara har en enda del. Den här algoritmen löser inte upp överlappande geometrier - de samlas ihop utan att formen på varje geometridel ändras.
Se algoritmerna ”Promote to multipart” eller ”Aggregate” för alternativa möjligheter.
Standardmeny:
Varning
Den här algoritmen tar bort befintliga primärnycklar eller FID-värden och återskapar dem i utdatalagren.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Unika ID-fält |
|
[tabellfält: valfritt] [lista] |
Välj ett eller flera attribut för att samla geometrierna |
Uppsamlad |
|
[samma som inmatning] |
Vektorlager med samlade geometrier |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Uppsamlad |
|
[samma som inmatning] Standard: |
Ange utdatavektorlagret för de insamlade geometrierna. Ett av:
Här kan du också ändra filkodningen. |
Python-kod
Algoritm-ID: native:samla
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.10. Konkavt skrov
Beräknar det konkava skrovet av funktionerna från ett inmatat punktlager.

Fig. 24.71 Konkava skrov med olika tröskelvärden (0,3, 0,6, 0,9)
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningspunktlager |
|
[vektor: punkt] |
Vektorlager för inmatningspunkt |
Tröskelvärde |
|
[numerisk: dubbel] Standard: 0,3 |
Tal från 0 (maximalt konkavt skrov) till 1 (konvext skrov). |
Tillåtna hål |
|
[boolean] Standard: Sann |
Välj om du vill tillåta hål i det slutliga konkava skrovet |
Dela upp geometrier med flera delar i geometrier med en del |
|
[boolean] Standard: Falsk |
Kontrollera om du vill ha endelade geometrier i stället för flerdelade. |
Konkavt skrov |
|
[vektor: polygon] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Konkavt skrov |
|
[vektor: polygon] |
Utgångsvektorlagret |
Python-kod
Algoritm-ID: `native:concavehull`
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.11. Konvertera geometrityp
Skapar ett nytt lager baserat på ett befintligt lager, med en annan typ av geometri.
Attributtabellen för det utgående lagret är densamma som för det ingående lagret.
Alla konverteringar är inte möjliga. Ett linjelager kan t.ex. konverteras till ett punktlager, men ett punktlager kan inte konverteras till ett linjelager.
Se även
Polygonisera, Denna algoritm skapar ett vektorlager med ett rutnät som täcker en angiven utsträckning. Elementen i rutnätet kan vara punkter, linjer eller polygoner. Storleken och/eller placeringen av varje elementen i rutnätet bestäms av de horisontella och vertikala avstånden. Koordinatsystemet i utdata måste anges. Rutnätets utsträckning och avståndsvärden måste anges i koordinaterna och enheterna för koordinatsystemet. Den övre vänstra punkten (minX, maxY) används som referenspunkt. Det betyder att, vid den punkten, är ett element garanterat att placeras. Om inte bredden och höjden av den valda utsträckningen är en multipel av de valda avstånden, är detta inte sant för de andra punkterna som definierar den utsträckningen., Polygoner till linjer, Pekar ut vägen
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Ny geometrityp |
|
[uppräkning] Standard: 0 |
Geometrityp som ska tillämpas på utdataobjekten. En av:
|
Varningen verifierar att en PDF-fil har lästs in i en bildram, där den rastreras eller konverteras till en bitmapp. Dess upplösning kan vara mindre än idealisk. Se PDF Export för att lära dig hur du minimerar detta problem. |
|
[vektor: geometri] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Varningen verifierar att en PDF-fil har lästs in i en bildram, där den rastreras eller konverteras till en bitmapp. Dess upplösning kan vara mindre än idealisk. Se PDF Export för att lära dig hur du minimerar detta problem. |
|
[vektor: geometri] |
Utgående vektorlager - typen beror på parametrarna |
Python-kod
Algoritm-ID: qgis:convertgeometrytype
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.12. Konvertera till krökta geometrier
Konverterar en geometri till dess krökta geometriekvivalent.
Redan krökta geometrier kommer att bibehållas utan ändringar.
Tillåter features in-place modification av linje- och polygonfeatures
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje eller polygon] |
Ingångsvektorlager |
Maximal tolerans för avstånd |
|
[numerisk: dubbel] Standard: 0,000001 |
Det maximala tillåtna avståndet mellan hörnens ursprungliga placering och var de skulle hamna i den konverterade krökta geometrin |
Maximal vinkeltolerans |
|
[numerisk: dubbel] Standard: 0,000001 |
Segment anses vara lämpliga att ersätta med en båge om alla punkter är regelbundet placerade på kandidatbågen. Denna parameter anger den maximala vinkelavvikelse (i grader) som tillåts vid test av regelbundet punktavstånd. Mellan 0 och 45°. |
Kurvor |
|
[vektor: sammansatt kurva eller kurvapolygon] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Kurvor |
|
[vektor: sammansatt kurva eller kurvapolygon] |
Utgående vektorlager med krökta geometrier |
Python-kod
Algoritm ID: native:konverteringskurvor
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.13. Konvex skrovform
Beräknar det konvexa skrovet för varje funktion i ett inmatningslager.
Se algoritmen ”Minimum bounding geometry” för en beräkning av ett konvext skrov som täcker hela lagret eller grupperade undergrupper av funktioner.

Fig. 24.72 Svarta linjer identifierar det konvexa skrovet för varje lagerfunktion
Tillåter features in-place modification av polygonfeatures
Standardmeny:
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Konvexa skrov |
|
[vektor: polygon] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Konvexa skrov |
|
[vektor: polygon] |
Vektorlagret för utdata (konvex skrov). Förutom inmatningsattributen innehåller utdatalagret också följande fält: |
Python-kod
Algoritm-ID: native:convexhull
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.14. Skapa lager från utsträckning
Skapar ett nytt vektorlager som innehåller en enda funktion med geometri som matchar omfattningen av inmatningslagret.
Den kan användas i modeller för att konvertera en bokstavlig utsträckning (formatet xmin
, xmax
, ymin
, ymax
) till ett lager som kan användas för andra algoritmer som kräver en lagerbaserad indata.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Extent (xmin, xmax, ymin, ymax) |
|
[omfattning] |
Inmatningens omfattning Tillgängliga metoder är:
|
Extent |
|
[vektor: polygon] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Extent |
|
[vektor: polygon] |
Vektorlagret för utdata (omfattning) |
Python-kod
Algoritm-ID: native:extenttolayer
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.15. Skapa lager från punkt
Skapar ett nytt vektorlager som innehåller en enda funktion med geometri som matchar en punktparameter. Det kan användas i modeller för att konvertera en punkt till ett punktlager för algoritmer som kräver en lagerbaserad inmatning.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Punkt |
|
[koordinater] |
Inmatningspunkt, inklusive CRS-information (exempel: Om CRS inte tillhandahålls kommer projektets CRS att användas. Punkten kan anges genom att klicka på kartbilden. |
Punkt |
|
[vektor: punkt] Standard: |
Ange utdatalagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Punkt |
|
[vektor: punkt] |
Vektorlagret för utdatapunkten som innehåller inmatningspunkten. |
Python-kod
Algoritm-ID: native:pointtolayer
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.16. Skapa kilbuffertar
Skapar kilformade buffertar från inmatningspunkter.

Fig. 24.73 Buffertar för kilar
Den ursprungliga utdata från denna algoritm är CurvePolygon-geometrier, men dessa kan automatiskt segmentiseras till polygoner beroende på utdataformatet.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: punkt] |
Vektorlager för inmatningspunkt |
Azimut (grader från norr) |
|
Standard: 0,0 |
Vinkel (i grader) som kilens mittvärde |
Kantbredd (i grader) |
|
Standard: 45,0 |
Bredd (i grader) på bufferten. Kilen kommer att sträcka sig till halva vinkelbredden på vardera sidan om azimutriktningen. ![]() Fig. 24.74 Azimut- och breddvärden för kilbufferten |
Yttre radie |
|
Standard: 1,0 |
Kilens yttre storlek (längd): storleken avser från källpunkten till kilformens kant. |
Innersta radien Valfritt |
|
Standard: 0,0 |
Värde för inre radie. Om 0 kommer kilen att börja från källpunkten. |
Buffertar |
|
[vektor: polygon] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Buffertar |
|
[vektor: polygon] |
Det utgående (kilbufferten) vektorlagret |
Python-kod
Algoritm-ID: native:wedgebuffers
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.17. Delaunay-triangulering
Skapar ett polygonlager med Delaunay-triangulering som motsvarar det inmatade punktlagret.

Fig. 24.75 Delaunay-triangulering på punkter
Standardmeny:
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: punkt] |
Vektorlager för inmatningspunkt |
Tolerans Valfritt |
|
[numerisk: dubbel] Standard: 0,0 |
Anger en valfri snäppningstolerans som kan användas för att förbättra trianguleringens robusthet. |
Lägg till punkt-ID:n i utdata |
|
[boolean] Standard: Sann |
Anger om fält som lagrar ID för involverade punktfunktioner ska läggas till i utdata. Om False används ett ”id”-fält för att identifiera polygonerna. |
Delaunay-triangulering |
|
[vektor: polygon] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Delaunay-triangulering |
|
[vektor: polygon] |
Vektorlager för utdata (Delaunay-triangulering) |
Python-kod
Algoritm-ID: native:delaunaytriangulering
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.18. Ta bort hål
Tar ett polygonlager och tar bort hål i polygonerna. Det skapar ett nytt vektorlager där polygoner med hål har ersatts av polygoner med endast sin yttre ring. Attributen ändras inte.
En valfri parameter för minsta yta gör att endast hål som är mindre än ett angivet tröskelvärde för ytan tas bort. Om denna parameter lämnas på 0,0
tas alla hål bort.

Fig. 24.76 Före och efter rengöringen
Tillåter features in-place modification av polygonfeatures
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: polygon] |
Vektorlager för inmatad polygon |
Ta bort hål med area mindre än Valfritt |
|
Standard: 0,0 |
Endast hål med en yta som är mindre än detta tröskelvärde kommer att raderas. Med ett värde på |
Renad |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Renad |
|
[samma som inmatning] |
Det utgående (rensade) vektorlagret |
Python-kod
Algoritm-ID: native:radera hål
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.19. Förtätning efter antal
Tar ett polygon- eller linjelager och genererar ett nytt lager där geometrierna har ett större antal hörn än det ursprungliga lagret.
Om geometrierna har Z- eller M-värden kommer dessa att interpoleras linjärt vid de extra hörnen.
Antalet nya hörn som ska läggas till i varje segment anges som en inmatningsparameter.

Fig. 24.77 Röda punkter visar topparna före och efter förtätningen
Tillåter features in-place modification av linje- och polygonfeatures
Standardmeny:
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje, polygon] |
Vektorlager för linje- eller polygoninmatning |
Tillägg att lägga till |
|
[numerisk: heltal] Standard: 1 |
Antal toppar som ska läggas till i varje segment |
Densifierad |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Densifierad |
|
[samma som inmatning] |
Det utgående (förtätade) vektorlagret |
Python-kod
Algoritm-ID: native:densifygeometries
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.20. Förtätning med intervall
Tar ett polygon- eller linjelager och genererar ett nytt lager där geometrierna har ett större antal hörn än det ursprungliga lagret.
Geometrierna förtätas genom att lägga till regelbundet placerade extra hörn inuti varje segment så att det maximala avståndet mellan två hörn inte överstiger det angivna avståndet.
Om geometrierna har Z- eller M-värden kommer dessa att interpoleras linjärt vid de extra hörnen.
Denna algoritm exporterar ett vektorlager till en PostgreSQL-databas, där en ny tabell skapas.
Om du anger ett avstånd på 3 konverteras segmentet [0 0] -> [10 0]
till [0 0] -> [2,5 0] -> [5 0] -> [7,5 0] -> [10 0]
, eftersom det krävs 3 extra hörn på segmentet och ett avstånd på 2,5 gör att de fördelas jämnt över segmentet.

Fig. 24.78 Förtäta geometrin vid ett givet intervall
Tillåter features in-place modification av linje- och polygonfeatures
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje, polygon] |
Vektorlager för linje- eller polygoninmatning |
Intervall mellan toppar som ska läggas till |
|
Standard: 1,0 |
Maximalt avstånd mellan två på varandra följande toppar |
Densifierad |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Densifierad |
|
[samma som inmatning] |
Det utgående (förtätade) vektorlagret |
Python-kod
Algoritm-ID: `native:densifygeometriesgivenaninterval
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.21. Lös upp
Tar ett vektorlager och kombinerar dess funktioner till nya funktioner. Ett eller flera attribut kan anges för att upplösa funktioner som tillhör samma klass (med samma värde för de angivna attributen), alternativt kan alla funktioner upplösas till en enda funktion.
Alla utdatageometrier konverteras till multigeometrier. Om indata är ett polygonlager kommer gemensamma gränser för intilliggande polygoner som löses upp att raderas. Om den valfria inställningen ”Keep disjoint features separate” är aktiverad kommer funktioner och delar som inte överlappar eller rör vid varandra att exporteras som separata funktioner (i stället för delar av en enda flerdelad funktion).
Den resulterande attributtabellen kommer att ha samma fält som inmatningslagret. Värdena i utdataskiktets fält är värdena för den första indatafunktionen som bearbetas.

Fig. 24.79 Upplösning av ett lager till en enda flerdelad funktion
Standardmeny:
Varning
Den här algoritmen tar bort befintliga primärnycklar eller FID-värden och återskapar dem i utdatalagren.
Se även
Parametrar
Grundläggande parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Lös upp fältet/fälten Valfritt |
|
[tabellfält: valfritt] [lista] Standard: [] |
Objekt som har samma värde för det/de valda fälten ersätts med ett enda objekt och deras geometrier slås samman. Om inget fält anges upplöses alla funktioner, vilket resulterar i en enda (flerdelad) funktion. ![]() Fig. 24.80 Lös upp polygonlagret på ett gemensamt attribut (2 flerdelade funktioner) |
Upplöst |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Avancerade parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Håll isär olika funktioner |
|
[boolean] Standard: Falsk |
Delar av upplösta features exporteras som separata features (istället för delar av en multipart feature). ![]() Fig. 24.81 source (vänster), dissolve all (3 distinkta funktioner - höger) ![]() Fig. 24.82 källa (vänster), upplöses på fältet (5 distinkta funktioner - höger) |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Upplöst |
|
[samma som inmatning] |
Utgångsvektorlagret med upplösta geometrier |
Python-kod
Algoritm ID: native:upplösning
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.22. Drape (ställ in Z-värde från raster)
Använder värden som samplas från ett band i ett rasterlager för att ställa in Z-värdet för varje överlappande vertex i objektets geometri. Rastervärdena kan eventuellt skalas med en förinställd mängd.
Om det redan finns Z-värden i lagret skrivs de över med det nya värdet. Om inga Z-värden finns kommer geometrin att uppgraderas så att den inkluderar Z-dimensionen.
Tillåter features in-place modification av punkt-, linje- och polygonfeatures med Z aktiverat
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Ett rasterlager |
|
[raster] |
Rasterlager med Z-värden |
Bandnummer |
|
[rasterband] Standard: 1 |
Det rasterband som Z-värdena ska hämtas från |
Värde för NoData eller icke korsande hörn |
|
Standard: 0,0 |
Värde att använda om vertexen inte korsar (en giltig pixel i) rastret |
Skalfaktor |
|
Standard: 1,0 |
Skalningsvärde: bandvärdena multipliceras med detta värde. |
Offset |
|
Standard: 0,0 |
Offset-värde: det läggs algebraiskt till bandvärdena efter tillämpning av ”Scale factor”. |
Uppdaterad |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret (med Z-värden från rasterlagret). One of:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Uppdaterad |
|
[samma som inmatning] |
Det utgående vektorlagret med Z-värden från rasterlagret |
Python-kod
Algoritm-ID: native:setzfromraster
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.23. Släpp M/Z-värden
Tar bort M- (mått) eller Z- (höjd) värden från indatageometrier.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager med M- eller Z-värden |
Drop M Values |
|
[boolean] Standard: Falsk |
Tar bort M-värdena från geometrierna |
Drop Z Values |
|
[boolean] Standard: Falsk |
Tar bort Z-värdena från geometrierna |
Z/M droppade |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Z/M droppade |
|
[samma som inmatning] |
Det utgående vektorlagret (identiskt med det ingående lagret, förutom att M- och/eller Z-dimensionerna har tagits bort från geometrierna). |
Python-kod
Algoritm-ID: native:dropmzvalues
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.24. Eliminera utvalda polygoner
Kombinerar valda polygoner i inmatningslagret med vissa intilliggande polygoner genom att radera deras gemensamma gräns. Den angränsande polygonen kan antingen vara den med störst eller minst yta eller den som delar den största gemensamma gränsen med den polygon som ska elimineras.
Eliminate används normalt för att ta bort sliver-polygoner, dvs. små polygoner som är ett resultat av polygonskärningsprocesser där gränserna för indata är liknande men inte identiska.
Standardmeny:
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: polygon] |
Vektorlager för inmatad polygon |
Sammanfoga urvalet med den närliggande polygonen med |
|
[uppräkning] Standard: Ej inställd |
Välj den parameter som ska användas för att ta bort de markerade polygonerna:
|
Eliminerad |
|
[vektor: polygon] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Eliminerad |
|
[vektor: polygon] |
Det utgående polygonvektorlagret. |
Python-kod
Algoritm-ID: qgis:eliminerar utvalda polygoner
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.25. Explodera linjer
Tar ett linjelager och skapar ett nytt där varje linjelager ersätts av en uppsättning linjer som representerar segmenten i den ursprungliga linjen.
Varje linje i det resulterande lagret innehåller bara en start- och en slutpunkt, utan några mellanliggande hörnpunkter mellan dem.
Om inmatningslagret består av CircularStrings eller CompoundCurves kommer utdatalagret att vara av samma typ och endast innehålla enstaka kurvsegment.
Observera
Den här algoritmen tar bort befintliga primärnycklar eller FID-värden och återskapar dem i utdatalagren.
Denna algoritm kräver inte giltiga geometrier som indata.

Fig. 24.83 Det ursprungliga linjelagret och det sprängda
Tillåter funktioner på plats modifiering av linjefunktioner
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Ingångslinje vektorlager |
Exploded |
|
[vektor: linje] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Exploded |
|
[vektor: linje] |
Det utgående linjevektorlagret med funktioner som representerar varje segment i det ingående lagret. |
Python-kod
Algoritm-ID: native:explodelines
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.26. Förlänga linjer
Förlänger linjens geometri med en angiven mängd i början och slutet av linjen.
Linjer förlängs med hjälp av bäringen för det första och sista segmentet i linjen.

Fig. 24.84 De röda strecken representerar den initiala och slutliga förlängningen av det ursprungliga lagret
Tillåter funktioner på plats modifiering av linjefunktioner
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Ingångslinje vektorlager |
Startavstånd |
|
Standard: 0,0 |
Avstånd med vilket linjens första segment ska förlängas (startpunkt) |
Slutavstånd |
|
Standard: 0,0 |
Avstånd med vilket linjens sista segment ska förlängas (slutpunkt) |
Utökad |
|
[vektor: linje] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Utökad |
|
[vektor: linje] |
Det utgående (utökade) linjevektorskiktet. |
Python-kod
Algoritm-ID: native:extendlines
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.27. Extrahera M-värden
Extraherar M-värden från geometrier till funktionsattribut.
Som standard extraheras endast M-värdet från det första vertexet i varje funktion, men algoritmen kan som tillval beräkna statistik för alla geometrins M-värden, inklusive summa, medelvärde, minimum och maximum.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Summa att beräkna |
|
[uppräkning] Standard: [0] |
Statistik över M-värdena i en geometri. En eller flera av:
|
Prefix för utdatakolumn |
|
[sträng] Standard: ”m_ |
Prefixet för kolumnen för utdata (M) |
Extraherad |
|
[samma som inmatning] Standard: |
Ange utdatalagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Extraherad |
|
[samma som inmatning] |
Utgångsvektorlagret (med M värden) |
Python-kod
Algoritm-ID: native:extraheravärden
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.28. Extrahera specifika toppar
Tar ett vektorlager och genererar ett punktlager med punkter som representerar specifika hörn i indatageometrierna.
Den här algoritmen kan t.ex. användas för att extrahera den första eller sista punkten i geometrin. De attribut som är associerade med varje punkt är desamma som är associerade med den funktion som vertexen tillhör.
Parametern vertex indices accepterar en kommaseparerad sträng som anger indexen för de toppar som ska extraheras. Det första vertexet motsvarar index 0, det andra vertexet har index 1 osv. Negativa index kan användas för att hitta toppar i slutet av geometrin, t.ex. motsvarar ett index på -1 den sista toppunkten, -2 motsvarar den näst sista toppunkten osv.
Ytterligare fält läggs till i vertikalerna som anger den specifika vertexpositionen (t.ex. 0, -1, etc.), det ursprungliga vertexindexet, vertexens del och dess index inom delen (samt dess ring för polygoner), avstånd längs den ursprungliga geometrin och bisectorvinkel för vertex för den ursprungliga geometrin.
Tillåter features in-place modification av punktfeatures
Varning
Den här algoritmen tar bort befintliga primärnycklar eller FID-värden och återskapar dem i utdatalagren.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Vertexindex |
|
[sträng] Standard: ’0’ |
Kommaseparerad sträng med index för de hörnpunkter som ska extraheras. |
Vertices |
|
[vektor: punkt] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Vertices |
|
[vektor: punkt] |
Utmatningsvektorn (punktvektorn) som innehåller de angivna hörnpunkterna från ingångslagrets geometrier. Förutom ingångsattributen innehåller utmatningslagret även följande fält:
|
Python-kod
Algoritm-ID: native:extrahera specifika vertikaler
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.29. Extrahera toppar
Tar ett vektorlager och genererar ett punktlager med punkter som representerar hörnen i indatageometrierna.
De attribut som är kopplade till varje punkt är desamma som är kopplade till den funktion som vertexen tillhör.
Ytterligare fält läggs till i vertikalerna och anger vertexindex (med början vid 0), objektets del och dess index inom delen (samt dess ring för polygoner), avstånd längs originalgeometrin och vertexets bisektionsvinkel för originalgeometrin.

Fig. 24.85 Extraherade hörnpunkter för linje- och polygonlager
Tillåter features in-place modification av punktfeatures
Standardmeny:
Varning
Den här algoritmen tar bort befintliga primärnycklar eller FID-värden och återskapar dem i utdatalagren.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Vertices |
|
[vektor: punkt] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Vertices |
|
[vektor: punkt] |
Det utgående (punkt) vektorlagret som innehåller hörnpunkterna från det inmatade lagrets geometrier. Förutom de inmatade attributen innehåller det utgående lagret även följande fält:
|
Python-kod
Algoritm-ID: `native:extrahera vertikaler
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.30. Extrahera Z-värden
Extraherar Z-värden från geometrier till funktionsattribut.
Som standard extraheras endast Z-värdet från det första toppunktet i varje funktion, men algoritmen kan som tillval beräkna statistik för alla geometrins Z-värden, inklusive summa, medelvärde, minimum och maximum.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Summa att beräkna |
|
[uppräkning] Standard: [0] |
Statistik över Z-värdena i en geometri. En eller flera av:
|
Prefix för utdatakolumn |
|
[sträng] Standard: ”z_ |
Prefixet för den utgående (Z) kolumnen |
Extraherad |
|
[samma som inmatning] Standard: |
Ange utdatalagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Extraherad |
|
[samma som inmatning] |
Utgångsvektorlagret (med Z-värden) |
Python-kod
Algoritm-ID: native:extraherazvärden
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.31. Filtrera toppar efter M-värde
Filtrerar bort toppunkter baserat på deras M-värde och returnerar geometrier med endast toppunkter som har ett M-värde som är större än eller lika med det angivna minimivärdet och/eller mindre än eller lika med maximivärdet.
Om minimivärdet inte anges testas endast maximivärdet, och på samma sätt om maximivärdet inte anges testas endast minimivärdet.

Fig. 24.86 Den röda linjen representerar den svarta linjen med endast toppar vars M-värde är <=10.
Tillåter features in-place modification av punkt-, linje- och polygonfunktioner med M aktiverat
Varning
Beroende på indatageometriattributen och de filter som används kan det hända att de geometrier som skapas med den här algoritmen inte längre är giltiga.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager för att ta bort toppar från |
Minimum Valfritt |
|
Standard: Ej inställd |
Minsta tillåtna M-värden |
Maximalt Valfritt |
|
Standard: Ej inställd |
Maximalt antal M värden tillåtna |
Filtrerad |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Filtrerad |
|
[samma som inmatning] |
Utgångsvektorlagret av funktioner med endast de filtrerade topparna. |
Python-kod
Algoritm-ID: native:filterverticesbym
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.32. Filtrera toppar efter Z-värde
Filtrerar bort toppunkter baserat på deras Z-värde och returnerar geometrier med endast toppunkter som har ett Z-värde som är större än eller lika med det angivna minimivärdet och/eller mindre än eller lika med maximivärdet.
Om minimivärdet inte anges testas endast maximivärdet, och på samma sätt om maximivärdet inte anges testas endast minimivärdet.

Fig. 24.87 Den röda linjen representerar den svarta linjen med endast toppar vars Z-värde är <=10.
Tillåter features in-place modification av punkt-, linje- och polygonfeatures med Z aktiverat
Varning
Beroende på indatageometriattributen och de filter som används kan det hända att de geometrier som skapas med den här algoritmen inte längre är giltiga. Du kan behöva köra algoritmen Fixa geometrier för att säkerställa att de är giltiga.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager för att ta bort toppar från |
Minimum Valfritt |
|
Standard: Ej inställd |
Minsta tillåtna Z-värden |
Maximalt Valfritt |
|
Standard: Ej inställd |
Maximalt antal Z-värden tillåtna |
Filtrerad |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Filtrerad |
|
[samma som inmatning] |
Utgångsvektorlagret av funktioner med endast de filtrerade topparna. |
Python-kod
Algoritm-ID: native:filterverticesbyz
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.33. Fixa geometrier
Försöker skapa en giltig representation av en given ogiltig geometri utan att förlora någon av de ingående topparna. Redan giltiga geometrier returneras utan ytterligare åtgärder. Skickar alltid ut lager med flera geometrier.
Tillåter features in-place modification av punkt-, linje- och polygonfunktioner utan M aktiverat
Varning
M-värden kommer att tas bort från utdata.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Reparationsmetod |
|
[uppräkning] Standard: 1 |
Metod som används för att reparera geometrierna. En av:
|
Fasta geometrier |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Fasta geometrier |
|
[samma som inmatning] |
Utgångsvektorlagret med fasta geometrier. |
Python-kod
Algoritm-ID: native:fixgeometrier
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.34. Kraft högerhands-regel
Tvingar polygongeometrier att följa högerhandsregeln, enligt vilken det område som avgränsas av en polygon ligger till höger om gränsen. I synnerhet är den yttre ringen orienterad i medurs riktning och alla inre ringar i moturs riktning.
Tillåter features in-place modification av polygonfeatures
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: polygon] |
Ingångsvektorlager |
Omorienterad |
|
[vektor: polygon] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Omorienterad |
|
[vektor: polygon] |
Utgångsvektorlagret med omorienterade geometrier. |
Python-kod
Algoritm-ID: native:forcerhr
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.35. Geodetisk linje delad vid antimeridianen
Delar upp en linje i flera geodetiska segment när linjen korsar antimeridianen (±180 graders longitud).
Delning vid antimeridianen underlättar den visuella framställningen av linjerna i vissa projektioner. Den returnerade geometrin kommer alltid att vara en geometri med flera delar.
När linjesegment i indatageometrin korsar antimeridianen delas de upp i två segment, varvid brytpunktens latitud bestäms med hjälp av en geodetisk linje som förbinder punkterna på vardera sidan om detta segment. Projektets aktuella ellipsoidinställning kommer att användas vid beräkning av denna brytpunkt.
Om indatageometrin innehåller M- eller Z-värden kommer dessa att interpoleras linjärt för de nya hörn som skapas vid antimeridianen.
Observera
Den här algoritmen använder ellipsoidbaserade mätningar och respekterar de aktuella ellipsoidinställningarna.
Tillåter funktioner på plats modifiering av linjefunktioner
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Ingångslinje vektorlager |
Split |
|
[vektor: linje] Standard: |
Ange utdatans linjevektorlager. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Split |
|
[vektor: linje] |
Utgångslinjens vektorlager delas vid antimeridianen. |
Python-kod
Algoritm-ID: native:antimeridiansplit
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.36. Geometri genom uttryck
Uppdaterar befintliga geometrier (eller skapar nya geometrier) för indatafunktioner med hjälp av ett QGIS-uttryck.
Detta möjliggör komplexa geometrimodifieringar som kan utnyttja all flexibilitet i QGIS uttrycksmotor för att manipulera och skapa geometrier för utdatafunktioner.
För hjälp med QGIS uttrycksfunktioner, se den inbyggda hjälp som finns i expression builder.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: vilken som helst] |
Ingångsvektorlager |
Typ av geometri för utdata |
|
[uppräkning] Standard: 0 |
Geometrin för utdata är starkt beroende av uttrycket: om du t.ex. skapar en buffert måste geometritypen vara polygon. En av följande:
|
Utgångsgeometrin har z-värden |
|
[boolean] Standard: Falsk |
Välj om utdatageometrin ska inkludera Z-dimensionen |
Utgångsgeometrin har m värden |
|
[boolean] Standard: Falsk |
Välj om utdatageometrin ska inkludera M-dimensionen |
Geometriskt uttryck |
|
[uttryck] Standard: ’$geometry’ |
Lägg till det geometriska uttryck som du vill använda. Du kan använda knappen för att öppna dialogrutan Expression. I dialogen listas alla relevanta uttryck, tillsammans med deras hjälp och guide. |
Modifierad geometri |
|
[vektor: geometri] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Modifierad geometri |
|
[vektor: geometri] |
Utgångsvektorlagret |
Python-kod
Algoritm-ID: native:geometrybyexpression
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.37. Interpolera punkt på linje
Skapar en punktgeometri som interpoleras på ett angivet avstånd längs linje- eller kurvgeometrier.
Z- och M-värdena interpoleras linjärt från befintliga värden.
Om en geometri med flera delar påträffas beaktas endast den första delen vid beräkningen av delsträngen.
Om det angivna avståndet är större än den inmatade funktionens längd, kommer den resulterande funktionen att ha en nollgeometri.

Fig. 24.88 Interpolerad punkt 500 meter från linjens början
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje, polygon] |
Vektorlager för linje- eller polygoninmatning |
Avstånd inom vilket ett objekt kommer att snäppa till dina placerade stödlinjer. Efter att du har ställt in detta måste du starta om Scribus för att ställa in denna inställning. |
|
Standard: 0,0 |
Avstånd från början av linjen |
Interpolerade punkter |
|
[vektor: punkt] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Interpolerade punkter |
|
[vektor: punkt] |
Utgångspunktens vektorlager med objekt på ett visst avstånd längs linjen eller polygongränsen |
Python-kod
Algoritm-ID: native:interpolatepoint
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.38. Behåll de största delarna
Tar ett lager med polygoner eller multipolygoner och returnerar ett nytt lager där endast de n största polygonerna i varje multipolygonfunktion sparas. Om en funktion har n eller färre delar kommer funktionen bara att kopieras.

Fig. 24.89 Medurs från övre vänstra hörnet: originalfilm i flera delar, en, två och tre största delar hålls
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Polygoner |
|
[vektor: polygon] |
Vektorlager för inmatad polygon |
** Delar som ska behållas** |
|
Standard: 1 |
Antal delar som ska behållas. Om 1, kommer endast den största delen av funktionen att behållas. |
Parts (delar) |
|
[vektor: polygon] Standard: |
Ange det utgående polygonvektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Parts (delar) |
|
[vektor: polygon] |
Det utgående polygonvektorlagret med de N största delarna av varje egenskap |
Python-kod
Algoritm ID: qgis:keepnbiggestparts
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.39. Linje delsträng
Returnerar den del av en linje (eller kurva) som ligger mellan de angivna start- och slutavstånden (mätt från linjens början).
Z- och M-värdena interpoleras linjärt från befintliga värden.
Om en geometri med flera delar påträffas beaktas endast den första delen vid beräkningen av delsträngen.

Fig. 24.90 Substringslinje med startavståndet inställt på 0 meter och slutavståndet på 250 meter.
Tillåter funktioner på plats modifiering av linjefunktioner
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Ingångslinje vektorlager |
Startavstånd |
|
Standard: 0,0 |
Avstånd längs inmatningslinjen till startpunkten för utmatningsfunktionen |
Slutavstånd |
|
Standard: 1,0 |
Avstånd längs inmatningslinjen till slutpunkten för utmatningsfunktionen |
Substräng |
|
[vektor: linje] Standard: |
Ange utdatans linjevektorlager. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Substräng |
|
[vektor: linje] |
Det utgående linjevektorlagret. |
Python-kod
Algoritm-ID: native:linjesubsträng
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.40. Denna algoritm skapar ett vektorlager med ett rutnät som täcker en angiven utsträckning. Elementen i rutnätet kan vara punkter, linjer eller polygoner. Storleken och/eller placeringen av varje elementen i rutnätet bestäms av de horisontella och vertikala avstånden. Koordinatsystemet i utdata måste anges. Rutnätets utsträckning och avståndsvärden måste anges i koordinaterna och enheterna för koordinatsystemet. Den övre vänstra punkten (minX, maxY) används som referenspunkt. Det betyder att, vid den punkten, är ett element garanterat att placeras. Om inte bredden och höjden av den valda utsträckningen är en multipel av de valda avstånden, är detta inte sant för de andra punkterna som definierar den utsträckningen.
Genererar ett polygonlager med linjerna från ett inmatat linjelager som polygonringar.
Attributtabellen för det utgående lagret är densamma som för det ingående lagret.
Standardmeny:
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Ingångslinje vektorlager |
Polygoner |
|
[vektor: polygon] Standard: |
Ange det utgående polygonvektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Polygoner |
|
[vektor: polygon] |
Det utgående polygonvektorlagret. |
Python-kod
Algoritm-ID: qgis:linestopolygoner
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.41. Sammanfoga linjer
Sammanfogar alla anslutna delar av MultiLineString-geometrier till enkla LineString-geometrier.
Om några delar av de inmatade MultiLineString-geometrierna inte är anslutna, kommer den resulterande geometrin att vara en MultiLineString som innehåller alla linjer som kan slås samman och alla icke anslutna linjedelar.
Tillåter funktioner på plats modifiering av linjefunktioner
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Ingångslinje vektorlager |
Sammanslagna |
|
[vektor: linje] Standard: |
Ange utdatans linjevektorlager. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Sammanslagna |
|
[vektor: linje] |
Det utgående (sammanslagna) linjevektorlagret. |
Python-kod
Algoritm-ID: native:mergelines
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.42. Minsta begränsande geometri
Skapar geometrier som omsluter objekten från ett inmatningslager. Funktionerna kan grupperas med ett fält. Utmatningslagret kommer sedan att innehålla en funktion per gruppvärde med en geometri (MBB) som täcker geometrierna för funktionerna med matchande värde.
Följande typer av omslutande geometrier stöds:
begränsande låda (kuvert)
orienterad rektangel
cirkel
konvex skrov

Fig. 24.91 Medurs från övre vänstra hörnet: kuvert, orienterad rektangel, cirkel, konvex kropp
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Textfält Valfritt |
|
[tabellfält: alla] |
Funktioner kan grupperas med ett fält. Om detta anges kommer utdatalagret att innehålla en funktion per grupperat värde med en minimal geometri som endast täcker funktionerna med matchande värden. |
Typ av geometri |
|
[uppräkning] Standard: 0 |
Omslutande geometrityper. En av:
|
Avgränsande geometri |
|
[vektor: polygon] Standard: |
Ange det utgående polygonvektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Avgränsande geometri |
|
[vektor: polygon] |
Det utgående (avgränsande) polygonvektorlagret. Det har fälten från det inkommande lagret och, beroende på den valda parametern
|
Python-kod
Algoritm-ID: qgis:minimumboundinggeometry
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.43. Minsta omslutande cirklar
Beräknar de minsta omslutande cirklarna för objekten i inmatningslagret.

Fig. 24.92 Omslutande cirklar för varje funktion
Tillåter features in-place modification av polygonfeatures
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Antal segment i cirklar |
|
[numerisk: heltal] Standard: 72 |
Antalet segment som används för att approximera en cirkel. Minimum 8, maximum 100000. |
Minsta omslutande cirklar |
|
[vektor: polygon] Standard: |
Ange det utgående polygonvektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Minsta omslutande cirklar |
|
[vektor: polygon] |
Det utgående polygonvektorlagret. Förutom inmatningsattributen innehåller utdatalagret även följande fält: |
Python-kod
Algoritm-ID: native:minimumenclosingcircle
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.44. Buffert med flera ringar (konstant avstånd)
Beräknar en buffert med flera ringar (donut) för funktionerna i inmatningslagret med hjälp av ett fast eller dynamiskt avstånd och antal ringar.

Fig. 24.93 Buffert med flera ringar för ett linje-, punkt- och polygonlager
Tillåter features in-place modification av polygonfeatures
Varning
Den här algoritmen tar bort befintliga primärnycklar eller FID-värden och återskapar dem i utdatalagren.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Antal ringar |
|
Standard: 1 |
Antalet ringar. Det kan vara ett unikt värde (samma antal ringar för alla funktioner) eller så kan det hämtas från funktionsdata (antalet ringar beror på funktionsvärden). |
Avstånd mellan ringarna |
|
Standard: 1,0 |
Avstånd mellan ringarna. Det kan vara ett unikt värde (samma avstånd för alla funktioner) eller så kan det hämtas från funktionsdata (avståndet beror på funktionsvärden). |
Buffert med flera ringar (konstant avstånd) |
|
[vektor: polygon] Standard: |
Ange det utgående polygonvektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Buffert med flera ringar (konstant avstånd) |
|
[vektor: polygon] |
Det utgående polygonvektorlagret. Förutom ingångsattributen innehåller utdatalagret även följande fält: |
Python-kod
Algoritm-ID: native:multiringconstantbuffer
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.45. Flera delar till enstaka delar
Delar upp flerdelade funktioner i inmatningslagret i endelade funktioner.
Attributen i utmatningslagret är desamma som de ursprungliga men uppdelade i enskilda funktioner.

Fig. 24.94 Till vänster källagret med flera delar och till höger utmatningsresultatet med en enda del
Tillåter features in-place modification av punkt-, linje- och polygonfeatures
Standardmeny:
Varning
Den här algoritmen tar bort befintliga primärnycklar eller FID-värden och återskapar dem i utdatalagren.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Enskilda delar |
|
[samma som inmatning] Standard: |
Ange det utgående polygonvektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Enskilda delar |
|
[samma som inmatning] |
Utgångsvektorlagret. |
Python-kod
Algoritm-ID: `native:multiparttosingleparts`
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.46. Offset-linjer
Förskjuter linjer med ett angivet avstånd. Positiva avstånd förskjuter linjerna åt vänster och negativa avstånd förskjuter dem åt höger.

Fig. 24.95 I blått källagret, i rött det förskjutna lagret
Tillåter funktioner på plats modifiering av linjefunktioner
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Ingångslinje vektorlager |
Avstånd inom vilket ett objekt kommer att snäppa till dina placerade stödlinjer. Efter att du har ställt in detta måste du starta om Scribus för att ställa in denna inställning. |
|
Standard: 10.0 |
Offset-avstånd. Du kan använda knappen Data Defined till höger för att välja ett fält från vilket radien ska beräknas. På så sätt kan du ha olika radier för varje objekt (se Buffert med variabelt avstånd). |
Segment |
|
[numerisk: heltal] Standard: 8 |
Styr antalet linjesegment som ska användas för att approximera en kvartscirkel när man skapar avrundade offsets. |
Join style |
|
[uppräkning] Standard: 0 |
Anger om runda, geringade eller avfasade skarvar ska användas vid förskjutning av hörn i en linje. Alternativen är:
![]() Fig. 24.96 Runda, geringade och fasade fogningsstilar |
Mitergräns |
|
[numerisk: dubbel] Standard: 2,0 |
Ställer in det maximala avståndet från offsetgeometrin som ska användas när man skapar en geringad fog som en faktor av offsetavståndet (gäller endast för geringade fogstilar). Minsta värde: 1.0 ![]() Fig. 24.97 En 10 m buffert med en gräns på 2 och en 10 m buffert med en gräns på 1 |
Offset |
|
[vektor: linje] Standard: |
Ange utdatalagret (offset). Ett av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Offset |
|
[vektor: linje] |
Utgående (offset) linjelager |
Python-kod
Algoritm-ID: native:offsetline
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.47. Orienterad minsta avgränsande box
Beräknar den roterade rektangeln med minsta yta för varje funktion i inmatningslagret.

Fig. 24.98 Orienterad minsta avgränsande box
Tillåter features in-place modification av polygonfeatures
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Begränsande boxar |
|
[vektor: polygon] Standard: |
Ange det utgående polygonvektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Begränsande boxar |
|
[vektor: polygon] |
Det utgående polygonvektorlagret. Förutom ingångsattributen innehåller utdatalagret också följande fält: |
Python-kod
Algoritm-ID: `native:orientedminimumboundingbox
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.48. Ortogonalisera
Försöker ortogonalisera geometrierna i det inmatade linje- eller polygonlagret. Denna process flyttar geometrins hörnpunkter för att försöka göra varje vinkel i geometrin antingen till en rät vinkel eller en rak linje.

Fig. 24.99 I blått källagret och i rött ortogonaliserat resultat
Tillåter features in-place modification av linje- och polygonfeatures
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje, polygon] |
Vektorlager för linje- eller polygoninmatning |
Maximal vinkeltolerans (grader) |
|
[numerisk: dubbel] Standard: 15,0 |
Ange den maximala avvikelsen från en rät vinkel eller rak linje som en toppunkt kan ha för att den ska justeras. Mindre toleranser innebär att endast vertexar som redan är närmare räta vinklar kommer att justeras, och större toleranser innebär att vertexar som avviker mer från räta vinklar också kommer att justeras. |
Maximala iterationer för algoritmen |
|
[numerisk: heltal] Standard: 1000 |
Om du anger ett högre värde för det maximala antalet iterationer får du en mer ortogonal geometri till priset av extra bearbetningstid. |
Orthogonaliserad |
|
[samma som inmatning] Standard: |
Ange det utgående polygonvektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Orthogonaliserad |
|
[samma som inmatning] |
Det utgående polygonvektorlagret med justerade vinklar. |
Python-kod
Algoritm-ID: native:orthogonalize
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.49. Punkt på ytan
För varje funktion i inmatningslagret returneras en punkt som garanterat ligger på ytan av funktionens geometri.
Tillåter features in-place modification av punktfeatures
Varning
Den här algoritmen kan ta bort befintliga primärnycklar eller FID-värden och återskapa dem i utdatalagren, beroende på indataparametrarna.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Skapa en punkt på ytan för varje del |
|
Om den är markerad skapas en punkt för varje del av geometrin. |
|
Punkt |
|
[vektor: punkt] Standard: |
Ange utmatningspunktens vektorlager. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Punkt |
|
[vektor: punkt] |
Vektorlagret för utmatningspunkten. |
Python-kod
Algoritm-ID: native:pointonsurface
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.50. Punkter längs geometrin
Skapar punkter med regelbundna intervall längs linje- eller polygongeometrier. Skapade punkter får nya attribut som läggs till för avståndet längs geometrin och linjens vinkel vid punkten.
En valfri start- och slutoffset kan anges, som styr hur långt från geometrins start och slut punkterna ska skapas.

Fig. 24.100 Punkter skapade längs källinje-lagret
Varning
Den här algoritmen tar bort befintliga primärnycklar eller FID-värden och återskapar dem i utdatalagren.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje, polygon] |
Vektorlager för linje- eller polygoninmatning |
Avstånd inom vilket ett objekt kommer att snäppa till dina placerade stödlinjer. Efter att du har ställt in detta måste du starta om Scribus för att ställa in denna inställning. |
|
Standard: 1,0 |
Avstånd mellan två på varandra följande punkter längs linjen |
Startförskjutning |
|
Standard: 0,0 |
Avstånd från början av inmatningsraden, som representerar positionen för den första punkten. |
Slutavräkning |
|
Standard: 0,0 |
Avstånd från slutet av inmatningslinjen, som representerar den position bortom vilken ingen punktfunktion ska skapas. |
Interpolerade punkter |
|
[vektor: punkt] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Interpolerade punkter |
|
[vektor: punkt] |
Punktvektorlager med funktioner placerade längs linjer eller polygongränser i inmatningslagret. Förutom indataattributen för varje relaterad punkt innehåller utdatalagret också följande fält: |
Python-kod
Algoritm-ID: native:punkter längs linjer
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.51. Förskjutning av punkter
Givet ett avstånd identifierar närliggande punktfunktioner och fördelar dem radiellt över en cirkel vars centrum representerar deras barycenter. Ett bekvämt verktyg för att sprida överlappande funktioner.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: punkt] |
Vektorlager för inmatningspunkt |
Minsta avstånd till andra punkter |
|
[numerisk: dubbel] Standard: 1,0 |
Avstånd under vilket punkter anses vara nära. Nära funktioner fördelas helt och hållet. |
Förskjutningsavstånd |
|
[numerisk: dubbel] Standard: 1,0 |
Radie för den cirkel där närliggande funktioner placeras |
Horisontell fördelning för tvåpunktshus |
|
[boolean] Standard: Falsk |
När endast två punkter identifieras som nära varandra, justeras de horisontellt på cirkeln i stället för vertikalt. |
Displaced |
|
[vektor: punkt] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Displaced |
|
[vektor: punkt] |
Utgångspunkt vektorlager |
Python-kod
Algoritm-ID: qgis:poängförskjutning
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.52. Pol av otillgänglighet
Beräknar polen för otillgänglighet för ett polygonlager, vilket är den mest avlägsna interna punkten från ytans gräns.
Denna algoritm använder ”polylabel”-algoritmen (Vladimir Agafonkin, 2016), som är en iterativ metod som garanterat hittar den verkliga polen för otillgänglighet inom en angiven tolerans. En mer exakt tolerans (lägre värde) kräver fler iterationer och tar längre tid att beräkna.

Fig. 24.101 Pol av otillgänglighet
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: polygon] |
Ingångsvektorlager |
Tolerans |
|
[numerisk: dubbel] Standard: 1,0 |
Ställ in toleransen för beräkningen |
Punkt |
|
[vektor: punkt] Standard: |
Ange det utgående polygonvektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Punkt |
|
[vektor: punkt] |
Vektorlagret för utmatningspunkten. Det kommer att innehålla ett nytt attribut med avståndet |
Python-kod
Algoritm ID: native:poleofinaccessibility
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.53. Polygonisera
Skapar ett polygonlager vars gränser genereras från ett linjelager med slutna objekt.

Fig. 24.102 De gula polygonerna som genereras från de slutna linjerna
Observera
Linjelagret måste ha slutna former för att kunna omvandlas till en polygon.
Se även
Polygoner till linjer, Denna algoritm skapar ett vektorlager med ett rutnät som täcker en angiven utsträckning. Elementen i rutnätet kan vara punkter, linjer eller polygoner. Storleken och/eller placeringen av varje elementen i rutnätet bestäms av de horisontella och vertikala avstånden. Koordinatsystemet i utdata måste anges. Rutnätets utsträckning och avståndsvärden måste anges i koordinaterna och enheterna för koordinatsystemet. Den övre vänstra punkten (minX, maxY) används som referenspunkt. Det betyder att, vid den punkten, är ett element garanterat att placeras. Om inte bredden och höjden av den valda utsträckningen är en multipel av de valda avstånden, är detta inte sant för de andra punkterna som definierar den utsträckningen., Konvertera geometrityp
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Ingångslinje vektorlager |
Behåll fält från inmatningslagret |
|
[boolean] Standard: Falsk |
Kontrollera att fälten (endast tabellstrukturen, inte värdena) i inmatningslagret behålls |
Polygoner från linjer |
|
[vektor: polygon] Standard: |
Ange det utgående polygonvektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Polygoner från linjer |
|
[vektor: polygon] |
Det utgående polygonvektorlagret från linjer |
Python-kod
Algoritm-ID: native:polygonize
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.54. Polygoner till linjer
Tar ett polygonlager och skapar ett linjelager med linjer som representerar gränserna för polygonerna i inmatningslagret.
Attributtabellen för det utgående lagret är densamma som för det ingående lagret.

Fig. 24.103 Svarta linjer som resultat av algoritmen
Standardmeny:
Se även
Denna algoritm skapar ett vektorlager med ett rutnät som täcker en angiven utsträckning. Elementen i rutnätet kan vara punkter, linjer eller polygoner. Storleken och/eller placeringen av varje elementen i rutnätet bestäms av de horisontella och vertikala avstånden. Koordinatsystemet i utdata måste anges. Rutnätets utsträckning och avståndsvärden måste anges i koordinaterna och enheterna för koordinatsystemet. Den övre vänstra punkten (minX, maxY) används som referenspunkt. Det betyder att, vid den punkten, är ett element garanterat att placeras. Om inte bredden och höjden av den valda utsträckningen är en multipel av de valda avstånden, är detta inte sant för de andra punkterna som definierar den utsträckningen., Polygonisera, Konvertera geometrityp
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: polygon] |
Vektorlager för inmatad polygon |
Linjer: |
|
[vektor: linje] Standard: |
Ange utdatans linjevektorlager. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Linjer: |
|
[vektor: linje] |
Linjevektorlagret för utdata från polygoner |
Python-kod
Algoritm-ID: native:polygonstoliner
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.55. Projektpunkter (kartesiska)
Projicerar punktgeometrier med ett angivet avstånd och bäring (azimut).
Tillåter features in-place modification av punktfeatures
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: punkt] |
Vektorlager för inmatningspunkt |
Bearing (grader från norr) |
|
Standard: 0,0 |
Medsols vinkel från norr, i enheten grad (°) |
Avstånd inom vilket ett objekt kommer att snäppa till dina placerade stödlinjer. Efter att du har ställt in detta måste du starta om Scribus för att ställa in denna inställning. |
|
Standard: 1,0 |
Avstånd till offsetgeometrier, i lagerenheter |
Projicerad |
|
[vektor: punkt] Standard: |
Ange utmatningspunktens vektorlager. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Projicerad |
|
[vektor: punkt] |
Det utgående (projicerade) punktvektorlagret |
Python-kod
Algoritm-ID: native:projektpunktcartesian
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.56. Befordra till multipart
Tar ett vektorlager med enpartsgeometrier och genererar ett nytt där alla geometrier är flerparts.
Inmatade funktioner som redan är flerdelade funktioner kommer att förbli oförändrade.
Denna algoritm kan användas för att tvinga geometrier till multiparttyper för att vara kompatibla med dataleverantörer som kräver multipartfunktioner.
Tillåter features in-place modification av punkt-, linje- och polygonfeatures
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Multiparts |
|
[samma som inmatning] Standard: |
Ange det multiparta vektorlagret för utdata. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Multiparts |
|
[samma som inmatning] |
Det utgående flerdelade vektorlagret |
Python-kod
Algoritm-ID: native:promotetomulti
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.57. Rektanglar, ovaler, diamanter
Skapar ett buffertområde med rektangel-, oval- eller diamantform för varje egenskap i det inmatade punktlagret.
Formparametrarna kan vara fasta för alla funktioner eller dynamiska med hjälp av ett fält eller ett uttryck.

Fig. 24.104 Olika buffertformer med dynamiska parametrar
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: punkt] |
Vektorlager för inmatningspunkt |
Buffertens form |
|
[uppräkning] |
Den form som ska användas. En av:
|
Bredd |
|
Standard: 1,0 |
Bredd på buffertformen |
Höjd |
|
Standard: 1,0 |
Buffertformens höjd |
Rotation Valfritt |
|
Standard: 0,0 |
Rotation av buffertformen |
Antal segment |
|
[numerisk: heltal] Standard: 36 |
Antal segment för en hel cirkel (Ovalform) |
&Spara utdata… |
|
[vektor: polygon] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
&Spara utdata… |
|
[vektor: polygon] |
Det utgående vektorlagret (med buffertformerna) |
Python-kod
Algoritm-ID: ”original:rektanglarovalsdiamanter
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.58. Ta bort dubbletter av toppar
Tar bort duplicerade hörn från objekt, om borttagandet av hörnen inte resulterar i en degenererad geometri.
Parametern tolerance anger toleransen för koordinater när man avgör om hörnpunkterna är identiska.
Som standard beaktas inte Z-värden vid detektering av dubbletter av hörnpunkter. T.ex. kommer två hörn med samma X- och Y-koordinat men olika Z-värden fortfarande att betraktas som duplikat och ett av dem kommer att tas bort. Om parametern Use Z Value är true, testas även Z-värdena och hörn med samma X- och Y-koordinater men olika Z-värden behålls.
Tillåter features in-place modification av punkt-, linje- och polygonfeatures
Observera
Duplicerade vertikaler testas inte mellan olika delar av en geometri med flera delar, t.ex. kommer en geometri med flera punkter och överlappande punkter inte att ändras med den här metoden.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Tolerans |
|
Standard: 0,000001 |
Toppar som är närmare än det angivna avståndet betraktas som dubbletter |
Använd Z-värde |
|
Standard: Falsk |
Om parametern Use Z Value är true, testas även Z-värdena och toppar med samma X och Y men olika Z bibehålls. |
Renad |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Renad |
|
[samma som inmatning] |
Det utgående vektorlagret (utan dubbla toppar) |
Python-kod
Algoritm-ID: native:removeduplicatevertices
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.59. Ta bort nollgeometrier
Tar bort alla objekt som inte har en geometri från ett vektorlager. Alla andra funktioner kopieras oförändrade.
Funktioner med nollgeometrier kan sparas i ett separat lager.
Om Also remove empty geometries är markerat tar algoritmen bort objekt vars geometrier inte har några koordinater, dvs. geometrier som är tomma. I så fall kommer även null-utdata att återspegla detta alternativ, eftersom de innehåller både null- och tomma geometrier.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager (med geometrier som inte är NULL) |
Ta även bort tomma geometrier |
|
[boolean] |
|
Geometrier som inte är noll |
Valfritt |
[samma som inmatning] Standard: |
Ange utdatavektorlagret för geometrierna som inte är NULL (och inte tomma). En av:
Här kan du också ändra filkodningen. |
Null geometrier Valfritt |
|
[samma som inmatning] Standard: |
Ange utmatningsvektorlagret för NULL (och tomma) geometrier. Ett av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Null geometrier |
|
[samma som inmatning] |
Vektorlager för utdata (för NULL och, om så väljs, tomma geometrier) |
Geometrier som inte är noll |
|
[samma som inmatning] |
Det utgående vektorlagret (utan NULL och, om så väljs, tomma geometrier) |
Python-kod
Algoritm-ID: native:removenullgeometries
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.60. Omvänd riktning på linjen
Inverterar riktningen för ett linjelager.

Fig. 24.105 Före och efter inverteringen av riktningen
Tillåter funktioner på plats modifiering av linjefunktioner
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Ingångslinje vektorlager |
Omvänd |
|
[vektor: linje] Standard: |
Ange utdatans linjevektorlager. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Omvänd |
|
[vektor: linje] |
Vektorlagret för utdatalinjen (med omvända linjer) |
Python-kod
Algoritm-ID: `native:reverselinedirection
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.61. Rotera
Roterar objektgeometrier med den angivna vinkeln medurs. Rotationen sker runt varje objekts centroid, eller valfritt runt en unik förinställd punkt.
Tillåter features in-place modification av punkt-, linje- och polygonfeatures
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Rotation (grader medurs) |
|
Standard: 0,0 |
Rotationens vinkel i grader |
Rotationsförankringspunkt (x, y) Valfritt |
|
[punkt] Standard: Ej inställd |
X,Y-koordinater för den punkt som funktionerna ska roteras runt. Om den inte är inställd sker rotationen runt varje objekts centroid. |
Roterad |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret (med roterade geometrier). Ett av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Roterad |
|
[samma som inmatning] |
Utgångsvektorlagret med roterade geometrier |
Python-kod
Algoritm-ID: native:rotatefeatures
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.62. Rundhet
Beräknar rundheten för varje funktion och lagrar den som ett nytt fält roundness
. Ingångsvektorlagret måste innehålla polygoner.
Rundheten hos en polygon definieras som 4π × polygonens area / omkrets². Rundhetsvärdet varierar mellan 0 och 1. En perfekt cirkel har en rundhet på 1, medan en helt platt polygon har en rundhet på 0.
Observera
Algoritmen returnerar NULL för flerdelade polygonfunktioner.
Tillåter features in-place modification av polygonfeatures
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: polygon] |
Ingångsvektorlager |
Rundhet |
|
[vektor: polygon] Standard: |
Ange utmatningsvektorlagret (med rundhetsfält). En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Rundhet |
|
[samma som inmatning] |
Utmatningsvektorn med värdet |
Python-kod
Algoritm-ID: native:roundness
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.63. Segmentiera med maximal vinkel
Segmentiserar en geometri genom att omvandla krökta sektioner till linjära sektioner.
Segmentiseringen utförs genom att ange den maximalt tillåtna radievinkeln mellan hörn på den rätade geometrin (t.ex. vinkeln på den båge som skapas från den ursprungliga bågens mittpunkt till på varandra följande utgångshörn på den linjäriserade geometrin). Icke-krökta geometrier kommer att behållas utan ändring.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje, polygon] |
Vektorlager för linje- eller polygoninmatning |
Maximal vinkel mellan topparna (grader) |
|
Standard: 5,0 |
Maximal tillåten radievinkel mellan hörn på den uträtade geometrin |
Segmentiserad |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret (med segmentiserade geometrier). Ett av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Segmentiserad |
|
[samma som inmatning] |
Det utgående vektorlagret med segmentiserade geometrier |
Python-kod
Algoritm-ID: native:segmentizebymaxangle
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.64. Segmentiera efter maximalt avstånd
Segmentiserar en geometri genom att omvandla krökta sektioner till linjära sektioner.
Segmentiseringen utförs genom att ange det maximalt tillåtna offsetavståndet mellan originalkurvan och den segmentiserade representationen. Icke-krökta geometrier behålls utan förändring.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje, polygon] |
Vektorlager för linje- eller polygoninmatning |
Maximalt offsetavstånd |
|
Standard: 1,0 |
Maximalt tillåtet offsetavstånd mellan originalkurvan och den segmentiserade representationen, i lagerenheter. |
Segmentiserad |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret (med segmentiserade geometrier). Ett av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Segmentiserad |
|
[samma som inmatning] |
Det utgående vektorlagret med segmentiserade geometrier |
Python-kod
Algoritm-ID: native:segmentizebymaxdistance
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.65. Ställ in M-värde
Ställer in M-värdet för geometrier i ett lager.
Om det redan finns M-värden i lagret skrivs de över med det nya värdet. Om inga M-värden finns kommer geometrin att uppgraderas så att den innehåller M-värden och det angivna värdet kommer att användas som det ursprungliga M-värdet för alla geometrier.
Tillåter features in-place modification av punkt-, linje- och polygonfunktioner med M aktiverat
Tips
Använd knappen Identifiera funktioner för att kontrollera det extra M-värdet: resultaten finns tillgängliga i dialogrutan Identifiera resultat.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
M Värde |
|
Standard: 0,0 |
M-värde som ska tilldelas geometrierna |
M Tillagd |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
M Tillagd |
|
[samma som inmatning] |
Utgångsvektorlagret (med M-värden som tilldelats geometrierna) |
Python-kod
Algoritm-ID: native:setmvalue
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.66. Ställ in M-värde från raster
Använder värden som samplas från ett band i ett rasterlager för att ställa in M-värdet för varje överlappande vertex i objektets geometri. Rastervärdena kan eventuellt skalas med en förinställd mängd.
Om det redan finns M-värden i lagret skrivs de över med det nya värdet. Om det inte finns några M-värden kommer geometrin att uppgraderas för att inkludera M-värden.
Tillåter features in-place modification av punkt-, linje- och polygonfunktioner med M aktiverat
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Ett rasterlager |
|
[raster] |
Rasterlager med M-värden |
Bandnummer |
|
[rasterband] Standard: 1 |
Det rasterband från vilket M-värdena hämtas |
Värde för NoData eller icke korsande hörn |
|
Standard: 0,0 |
Värde att använda om vertexen inte korsar (en giltig pixel i) rastret |
Skalfaktor |
|
Standard: 1,0 |
Skalningsvärde: bandvärdena multipliceras med detta värde. |
Offset |
|
Standard: 0,0 |
Offset-värde: det läggs algebraiskt till bandvärdena efter tillämpning av ”Scale factor”. |
Uppdaterad |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret (med uppdaterade M-värden). En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Uppdaterad |
|
[samma som inmatning] |
Utgångsvektorlagret (med uppdaterade M-värden) |
Python-kod
Algoritm-ID: native:setmfromraster
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.67. Ställ in Z-värde
Ställer in Z-värdet för geometrier i ett lager.
Om det redan finns Z-värden i lagret skrivs de över med det nya värdet. Om inga Z-värden finns kommer geometrin att uppgraderas så att Z-värden inkluderas och det angivna värdet används som det initiala Z-värdet för alla geometrier.
Tillåter features in-place modification av punkt-, linje- och polygonfeatures med Z aktiverat
Tips
Använd knappen Identifiera funktioner för att kontrollera det extra Z-värdet: resultaten finns tillgängliga i dialogrutan Identifiera resultat.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Z-värde |
|
Standard: 0,0 |
Z-värde som ska tilldelas geometrierna för objekten |
Z Tillagd |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Z Tillagd |
|
[samma som inmatning] |
Utgångsvektorlagret (med tilldelade Z-värden) |
Python-kod
Algoritm-ID: native:setzvalue
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.68. Förenkla
Förenklar geometrierna i ett linje- eller polygonlager. Det skapar ett nytt lager med samma funktioner som i inmatningslagret, men med geometrier som innehåller ett lägre antal hörn.
Algoritmen ger ett urval av förenklingsmetoder, inklusive avståndsbaserad (Douglas-Peucker-algoritmen), områdesbaserad (Visvalingam-algoritmen) och snäppning av geometrier till rutnätet.

Fig. 24.106 Från vänster till höger, källager och ökande förenklingstoleranser
Tillåter features in-place modification av linje- och polygonfeatures
Standardmeny:
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje, polygon] |
Vektorlager för linje- eller polygoninmatning |
Förenklingsmetod |
|
[uppräkning] Standard: 0 |
Förenklingsmetod. En av:
|
Tolerans |
|
Standard: 1,0 |
Tröskeltolerans (i lagrets enheter): om avståndet mellan två noder är mindre än toleransvärdet förenklas segmentet och topparna tas bort. |
Förenklat |
|
[samma som inmatning] Standard: |
Ange det utgående (förenklade) vektorlagret. Ett av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Förenklat |
|
[samma som inmatning] |
Det utgående (förenklade) vektorlagret |
Python-kod
Algoritm-ID: native:simplifygeometries
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.69. Enkelsidig buffert
Beräknar en buffert på linjer med ett angivet avstånd på endast en sida av linjen.
Buffert resulterar alltid i ett polygonlager.

Fig. 24.107 Vänster- och högersidig buffert på samma vektorlinjelager
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Ingångslinje vektorlager |
Avstånd inom vilket ett objekt kommer att snäppa till dina placerade stödlinjer. Efter att du har ställt in detta måste du starta om Scribus för att ställa in denna inställning. |
|
Standard: 10.0 |
Buffertavstånd. |
Sida |
|
[uppräkning] Standard: 0 |
Vilken sida som bufferten ska skapas på. En av:
|
Segment |
|
[numerisk: heltal] Standard: 8 |
Styr antalet linjesegment som ska användas för att approximera en kvartscirkel när man skapar avrundade offsets. |
Join style |
|
[uppräkning] Standard: 0 |
Anger om runda, geringade eller avfasade skarvar ska användas vid förskjutning av hörn i en linje. Alternativen är:
![]() Fig. 24.108 Runda, geringade och fasade fogningsstilar |
Mitergräns |
|
[numerisk: dubbel] Standard: 2,0 |
Ställer in det maximala avståndet från offsetgeometrin som ska användas när man skapar en geringad fog som en faktor av offsetavståndet (gäller endast för geringade fogstilar). Minsta värde: 1.0 ![]() Fig. 24.109 En 10 m buffert med en gräns på 2 och en 10 m buffert med en gräns på 1 |
Buffert |
|
[vektor: polygon] Standard: |
Ange utdatalagret (buffert). En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Buffert |
|
[vektor: polygon] |
Utgående (buffert) polygonlager |
Python-kod
Algoritm-ID: native:singlesidedbuffer
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.70. Smidig
Utjämnar geometrierna i ett linje- eller polygonlager genom att lägga till fler vertikaler och hörn till geometrierna.
Parametern iterationer anger hur många utjämningsiterationer som ska tillämpas på varje geometri. Ett högre antal iterationer resulterar i jämnare geometrier, men till priset av ett större antal noder i geometrierna.

Fig. 24.110 Ökat antal iterationer ger jämnare geometrier
Offset-parametern styr hur ”tätt” de utjämnade geometrierna följer originalgeometrierna. Mindre värden ger en snävare passform och större värden ger en lösare passform.

Fig. 24.111 Blå: inmatningslagret. Offset 0,25 ger den röda linjen, medan offset 0,50 ger den gröna linjen.
Parametern för maximal vinkel kan användas för att förhindra utjämning av noder med stora vinklar. Alla noder där vinkeln mellan segmenten på vardera sidan är större än detta kommer inte att utjämnas. Om du t.ex. ställer in den maximala vinkeln till 90 grader eller lägre bevaras räta vinklar i geometrin.
Tillåter features in-place modification av linje- och polygonfeatures
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje, polygon] |
Vektorlager för linje- eller polygoninmatning |
Iterationer |
|
Standard: 1 |
Om du ökar antalet iterationer får du jämnare geometrier (och fler hörn). |
Offset |
|
Standard: 0,25 |
Ökande värden kommer att flytta de utjämnade linjerna/gränserna längre bort från de inmatade linjerna/gränserna. |
Maximal nodvinkel för att släta ut |
|
Standard: 180,0 |
Varje nod under detta värde kommer att jämnas ut |
Smoothed |
|
[samma som inmatning] Standard: |
Ange det utgående (utjämnade) lagret. Ett av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Smoothed |
|
[samma som inmatning] |
Utgående (utjämnat) vektorlager |
Python-kod
Algoritm-ID: native:jämngeometri
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.71. Fäst geometrier till lager
Snäpper geometrierna i ett lager antingen till geometrierna från ett annat lager eller till geometrier inom samma lager.
Matchningen görs baserat på ett toleransavstånd och hörnpunkter infogas eller tas bort efter behov för att geometrierna ska stämma överens med referensgeometrierna.
Tillåter features in-place modification av punkt-, linje- och polygonfeatures
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Reference layer |
|
[vektor: geometri] |
Vektorlager att snäppa till |
Tolerans |
|
[numerisk: dubbel] Standard: 10.0 |
Kontrollera hur nära ingångsvertices måste vara referenslagrets geometrier innan de snäppas. |
Beteende |
|
[uppräkning] Standard: 0 |
Snapping kan göras till en befintlig nod eller ett segment (dess närmaste punkt till den vertex som ska flyttas). Tillgängliga snapping-alternativ:
|
Snapped geometry |
|
[samma som inmatning] Standard: |
Ange det utgående (snäppta) lagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Snapped geometry |
|
[samma som inmatning] |
Utgång (snappad) vektorlager |
Python-kod
Algoritm-ID: `native:snapgeometrier`
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.72. Fäst punkter i rutnätet
Ändrar koordinaterna för geometrier i ett vektorlager, så att alla punkter eller hörn snappas till den närmaste punkten i ett rutnät.
Om den snäppta geometrin inte kan beräknas (eller om den är helt kollapsad) kommer objektets geometri att rensas.
Snapping kan utföras på X-, Y-, Z- eller M-axeln. Ett rutnätsavstånd på 0 för någon axel inaktiverar snäppning för den axeln.
Tillåter features in-place modification av punkt-, linje- och polygonfeatures
Varning
Snapping till rutnätet kan generera en ogiltig geometri i vissa hörnfall.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
avstånd mellan rutnätet och *X* |
|
Standard: 1,0 |
Rasteravstånd på X-axeln |
Avstånd mellan Y-rutorna |
|
Standard: 1,0 |
Rasteravstånd på Y-axeln |
Z Avstånd mellan rutnät |
|
Standard: 0,0 |
Rasteravstånd på Z-axeln |
M Rasteravstånd |
|
Standard: 0,0 |
Rasteravstånd på M-axeln |
Snapped |
|
[samma som inmatning] Standard: |
Ange det utgående (snäppta) lagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Snapped |
|
[samma som inmatning] |
Utgång (snappad) vektorlager |
Python-kod
Algoritm-ID: native:snappointstogrid
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.73. Dela upp linjerna efter maximal längd
Tar ett linje- (eller kurv-) lager och delar upp varje funktion i flera delar, där varje del har en angiven maximal längd. Z- och M-värdena i början och slutet av de nya linjesubstraten interpoleras linjärt från befintliga värden.
Tillåter funktioner på plats modifiering av linjefunktioner
Varning
Den här algoritmen tar bort befintliga primärnycklar eller FID-värden och återskapar dem i utdatalagren.
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Det ingående linjevektorlagret |
Maximal linjelängd |
|
Standard: 10.0 |
Den maximala längden på en rad i utdata. |
Split |
|
[vektor: linje] Standard: |
Ange utdatans linjevektorlager. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Split |
|
[vektor: linje] |
Det nya linjevektorlagret. Längden på funktionsgeometrierna är mindre än eller lika med den längd som anges i parametern LENGTH. Ett ytterligare fält som innehåller |
Python-kod
Algoritm-ID: native:splitlinesbylength
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.74. Dela upp
Delar upp geometrin. Den returnerade geometrin kommer att vara en samling som innehåller indelade delar från den ursprungliga geometrin, där ingen del har mer än det angivna maximala antalet noder.
Detta är användbart för att dela upp en komplex geometri i mindre komplexa delar, lättare att spatialt indexera och snabbare att utföra spatiala operationer. Krökta geometrier kommer att segmentiseras före subdivision.

Fig. 24.112 Vänster inmatningslager, mitten maximalt nodvärde är 100 och höger maximalt värde är 200
Tillåter features in-place modification av punkt-, linje- och polygonfeatures
Observera
Att dela upp en geometri kan generera geometridelar som kanske inte är giltiga och som kan innehålla självskärningar.
Se även
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlagret |
Maximala noder i delar |
|
Standard: 256 |
Maximalt antal hörnpunkter som varje ny geometridel får ha. Färre sub-parts för högre värden. |
Subdividerat |
|
[samma som inmatning] Standard: |
Ange det utgående (indelade) vektorlagret. Ett av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Subdividerat |
|
[samma som inmatning] |
Utgående vektorlager |
Python-kod
Algoritm-ID: native:underindelning
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.75. Byt X- och Y-koordinater
Växlar X- och Y-koordinatvärden i inmatade geometrier.
Den kan användas för att reparera geometrier som av misstag har fått sina latitud- och longitudvärden omvända.
Tillåter features in-place modification av punkt-, linje- och polygonfeatures
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlagret |
Utbytt |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Utbytt |
|
[samma som inmatning] |
Utgående (swappat) vektorlager |
Python-kod
Algoritm-ID: native:swapxy
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.76. Avsmalnande buffertar
Skapar avsmalnande buffert längs linjegeometrier med hjälp av en angiven start- och slutdiameter för bufferten.

Fig. 24.113 Exempel på avsmalnande buffert
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Ingångslinje vektorlager |
Startbredd |
|
Standard: 0,0 |
Representerar radien för den buffert som används vid startpunkten för linjefunktionen |
Slutbredd |
|
Standard: 0,0 |
Representerar radien för den buffert som appliceras vid slutpunkten för linjefunktionen. |
Segment |
|
Standard: 16 |
Styr antalet linjesegment som ska användas för att approximera en kvartscirkel när man skapar avrundade offsets. |
Buffrad |
|
[vektor: polygon] Standard: |
Ange utdatalagret (buffert). En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Buffrad |
|
[vektor: polygon] |
Utgående (buffert) polygonlager |
Python-kod
Algoritm-ID: native:taperedbuffer
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.77. Tessellat
Tessellerar ett lager med polygongeometrier genom att dela upp geometrierna i triangulära komponenter.
Utmatningslagret består av multipolygongeometrier för varje inmatad funktion, där varje multipolygon består av flera polygoner med triangelkomponenter.

Fig. 24.114 Tessellerad polygon (höger)
Tillåter features in-place modification av polygonfeatures
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: polygon] |
Vektorlager för inmatad polygon |
Tesselated |
|
[vektor: polygon] Standard: |
Ange utdatalagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Tesselated |
|
[vektor: polygon] |
Utmatning av multipolygonZ-lager |
Python-kod
Algoritm ID: 3d:tessellate
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.78. Transekt
Skapar transekter på hörn för (multi)linjestring.
En transekt är en linje som är orienterad från en vinkel (som standard vinkelrät) mot de inmatade polylinjerna (vid hörnen).
Fält från objekt returneras i transekten med dessa nya fält:
TR_FID: ID för den ursprungliga funktionen
TR_ID: ID för transekten. Varje transekt har ett unikt ID
TR_SEGMENT: ID för segmentet av linjesträngen
TR_ANGLE: Vinkel i grader från den ursprungliga linjen vid toppunktet
TR_LENGTH: Total längd på den returnerade transekten
TR_ORIENT: Transektens sida (endast till vänster eller höger om linjen, eller båda sidorna)
Varning
Den här algoritmen tar bort befintliga primärnycklar eller FID-värden och återskapar dem i utdatalagren.

Fig. 24.115 Streckade röda linjer representerar transekten för det ingående linjelagret
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Ingångslinje vektorlager |
Transektens längd |
|
Standard: 5,0 |
Transektens längd i kartanhet |
Vinkel i grader från den ursprungliga linjen vid hörnen |
|
Standard: 90,0 |
Ändra vinkeln på transekten |
Sida för att skapa transekten |
|
[uppräkning] |
Välj sida av transekten. Tillgängliga alternativ är:
|
Transekt |
|
[vektor: linje] Standard: |
Ange utmatningens linjelager. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Transekt |
|
[vektor: linje] |
Utgående linje lager |
Python-kod
Algoritm-ID: original:transekt
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.79. Översätt
Flyttar geometrierna inom ett lager genom att förskjuta dem med en fördefinierad X- och Y-förskjutning.
Z- och M-värden som finns i geometrin kan också översättas.

Fig. 24.116 Funktioner i rött representerar den översatta geometrin för inmatningslagret (blått)
Tillåter features in-place modification av punkt-, linje- och polygonfeatures
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: geometri] |
Ingångsvektorlager |
Förskjutet avstånd (x-axel) |
|
Standard: 0,0 |
Förskjutning som ska tillämpas på X-axeln |
Offset-avstånd (y-axeln) |
|
Standard: 0,0 |
Förskjutning som ska tillämpas på Y-axeln |
Offset-avstånd (z-axel) |
|
Standard: 0,0 |
Förskjutning som ska tillämpas på Z-axeln |
Offset-avstånd (m-värden) |
|
Standard: 0,0 |
Förskjutning som ska appliceras på M-axeln |
Översatt |
|
[samma som inmatning] Standard: |
Ange det utgående vektorlagret. En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Översatt |
|
[samma som inmatning] |
Utgående vektorlager |
Python-kod
Algoritm-ID: native:translategeometry
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.80. Buffert med variabel bredd (av M-värde)
Skapar buffertar med variabel bredd längs linjerna och använder M-värdet för linjegeometrierna som buffertens diameter vid varje toppunkt.

Fig. 24.117 Exempel på variabel buffert
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: linje] |
Ingångslinje vektorlager |
Segment |
|
Standard: 16 |
Antal buffertsegment per kvartscirkel. Det kan vara ett unikt värde (samma värde för alla objekt), eller så kan det hämtas från objektdata (värdet kan bero på objektattribut). |
Buffrad |
|
[vektor: polygon] Standard: |
Ange utdatalagret (buffert). En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Buffrad |
|
[vektor: polygon] |
Polygonlager med variabel buffert |
Python-kod
Algoritm-ID: native:bufferbym
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.
24.1.23.81. Voronoi-polygoner
Tar ett punktlager och genererar ett polygonlager som innehåller Voronoi-polygonerna (även kända som Thiessen-polygoner) som motsvarar dessa inmatningspunkter.
Varje plats inom en Voronoi-polygon är närmare den associerade punkten än någon annan punkt.

Fig. 24.118 Voronoi-polygoner
Standardmeny:
Parametrar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Inmatningslager |
|
[vektor: punkt] |
Vektorlager för inmatningspunkt |
Buffertregion (% of utsträckning) |
|
[numerisk: dubbel] Standard: 0,0 |
Utmatningslagrets omfattning kommer att vara så här mycket större än inmatningslagrets omfattning |
Tolerans Valfritt |
|
[numerisk: dubbel] Standard: 0,0 |
Anger en valfri snäpptolerans som kan användas för att förbättra robustheten hos voronoi. |
Kopiera attribut från inmatade funktioner |
|
[boolean] Standard: Sann |
Anger om fält som lagrar ID för involverade punktfunktioner ska läggas till i utdata. Om False, skapas ett fält med ”id” för att identifiera polygonerna. |
Voronoi-polygoner |
|
[vektor: polygon] Standard: |
Ange utdatalagret (med Voronoi-polygonerna). En av:
Här kan du också ändra filkodningen. |
Utgångar
Etikett |
Namn |
Typ |
Beskrivning |
---|---|---|---|
Voronoi-polygoner |
|
[vektor: polygon] |
Voronoi-polygoner för inmatningspunktens vektorlager |
Python-kod
Algoritm-ID: native:voronoipolygoner
import processing
processing.run("algorithm_id", {parameter_dictionary})
algoritm id visas när du håller muspekaren över algoritmen i verktygslådan Processing Toolbox. I parameter dictionary finns parameternamn och värden. Se Använda bearbetningsalgoritmer från konsolen för information om hur du kör bearbetningsalgoritmer från Python-konsolen.