Fiona returns Python dictionaries and you can not use poly['properties']['score']) += point['properties']['score']) with a dictionary.
Example of summing attributes using the references given by Mike T:
# read the shapefiles
from shapely.geometry import shape
polygons = [pol for pol in fiona.open('poly.shp')]
points = [pt for pt in fiona.open(...
over() from package sp can be a little confusing but works well. I'm assuming you've already made "A" spatial with coordinates(A) <- ~longitude+latitude:
# Overlay points and extract just the code column:
a.data <- over(A, B[,"code"])
Instead of a point spatial object, this simply gives you a data frame, with the same no. rows as A, and a single ...
Join Attributes by Location concatenates the following set of methods to compare geometries:
intersects if the intersection of both geometries is not empty
contains if the second geometry is completely contained into the first one
disjoint if the intersection of both geometries is the empty set
equals if they are spatially identical
touches if the only ...
To multiply the features do this (available to those who have ArcGIS 10.1 or above).
Place the features and table into the same file geodatabase (you must convert Shapefiles/Excel/DBF files into the geodatabase for this to work).
Make sure your polygons have a unique ID field that will be preserved (you can create a Long field and calculate the ObjectID ...
Don't think the QGIS docs has something as detailed as what is shown in the link in your comment (here is the link for English speakers). I would assume the terminology would be pretty much similar if not the same.
However, the tool uses the QgsGeometry Class which for each geometric predicate has the following basic description:
intersects - Test for ...
adding the argument op='within' in the sjoin function speeds up the point-in-polygon operation dramatically.
Default value is op='intersects', which I guess would also lead to correct result, but is 100 to 1000 times slower.
Additionally - geopandas now optionally includes rtree as a dependency, see the github repo
So, instead of following all the (very nice) code above, you could simply do something like:
from geopandas.tools import sjoin
point = geopandas.GeoDataFrame.from_file('point.shp') # or geojson etc
poly = geopandas.GeoDataFrame.from_file('poly.shp')...
The main difference is that in a classical join, inner (equi), left or right the joined fields or field must match exactly on both sides of the join, ie, in both tables you are joining.
In a spatial join, there is no notion of exactness. Instead you are joining on an intersection, containment or even distance between a geometry field in one table and a ...
The best tool for this job in my experience is Add polygon attributes to points in the Processing toolbox. If it does not work directly with the CSV, just save the points to a Shapefile before you run the spatial join.
What's likely going on here is that only the dataframe on the right is fed into the rtree index:
Which for an op="intersects" run would mean the Polygon was fed into the index, so for every point, the corresponding polygon is found through the rtree index.
But for op="within"...
One solution is to create a Virtual Layer and write some SQL.
Type the following query into the Query section of the dialog:
SELECT c.geometry, c.CITY_NAME, group_concat(z.code) AS ZIP_ids
FROM ZIPCODE z, CITY_AREA c
WHERE ST_Intersects(z.geometry, c.geometry)
GROUP BY c.CITY_NAME;
Adjust field names in the query. For example, I assumed ZIP codes are ...
In QGIS I can suggest using a "Virtual Layer" through Layer > Add Layer > Add/Edit Virtual Layer...
Let's assume we have two polygon layers "Layer_A" (brown) and "Layer_B" (green) respectively, see image below.
With the following query, it is possible to achieve the result, i.e. to perform a spatial join and put the ...
count(pid) FILTER (WHERE pid='w') AS "w",
count(pid) FILTER (WHERE pid='x') AS "x",
count(pid) FILTER (WHERE pid='y') AS "y",
count(pid) FILTER (WHERE pid='z') AS "z"
left join points
on st_intersects(points.geom, polygons.geom)) sub
GROUP BY polyname
Use Rtree as an index to perform the much faster joins, then Shapely to do the spatial predicates to determine if a point is actually within a polygon. If done properly, this can be faster than most other GISes.
See examples here or here.
The second part of your question concerning 'SUM', use a dict object to accumulate populations using a polygon id as ...
The point.in.poly function in the spatialEco package returns a SpatialPointsDataFrame object of the points that intersect an sp polygon object and optionally adds the polygon attributes.
First lets add the require packages and create some example data.
coordinates(meuse) = ~x+y
The question asks how to take advantage of r-tree in geopandas spatial joins, and another responder correctly points out that you should use 'within' instead of 'intersects'. However, you can also take advantage of an r-tree spatial index in geopandas while using intersects/intersection, as demonstrated in this geopandas r-tree tutorial:
spatial_index = gdf....
Create a polygon grid using the Vector Grid tool instead of lines. Make sure to check the polygon output.
Once you have a polygon grid (also known as fishnet), you can use the Sum line length tool in the QGIS Vector analysis tools. This will result in a new field for each cell with the total road length inside it
Here's a simple example of a vector ...
In QGIS Plugins you'll find a 'merge lines' plugin, which at first sight seems to accomplish what you are after.
cited from description:
Simplifies the topology of a line network by merging adjacent lines
This plugin merges segments of a line network (e.g. river network) in order to simplify its topology. Two merging methods are currently ...
Although @radouxju answer is valid, I will explain it a little more detailed.
You need to make sure that the polyline feature is split exactly above the point locations.
Use Join attribute by location. Choose the split line feature at point locations as target layer - in my case I name it "exploded".
In the summary section, select "Take summary of ...
You can try below query by getting the intersected area of both geometries and the total area of Parcel geometry, then get the percentage and compare it 90%:
CREATE TABLE test_join AS
SELECT t.*, m.*
FROM parcels AS t , historic_subdistricts AS m
where st_intersects(t.geom, m.geom) and
(st_area(st_intersection(t.geom, m.geom))/st_area(t.geom)) > 0.9
You may want to take a look at Shapely and Fiona. Fiona is a wrapper for gdal to make spatial file import and export easy. Shapely provides geometry functionality. Here is a very simple example to give you the idea. It joins polygon attributes to all points within that polygon.
The example data I have used are these polygons and these points.
First use a window function to get the ordered rank of the dem_points. In a second step filter the dem_point with the lowest dn by the rank.
SELECT osm_id, gid, dn
SELECT b.osm_id, p.gid, p.dn,
row_number() OVER (PARTITION BY osm_id order by dn) as rank
FROM buffer b, dem_points p
To manipulate the fields, their order, names, and other properties it is necessary to use the arcpy.FieldMappings() class. It is not very easy to get to know them and start using, so I've added extra comments to help you understand the workflow.
In this example, I am doing spatial join transferring just two fields from counties to cities.
There is not any bug in 'sjoin' method. To realize this, you also need Rtree python module (in my case installed with easy_install) and libspatialindex library (from my Debian Linux repository). After installation of these libraries, I ran my adapted version of your code:
from geopandas import gpd
points = gpd.GeoDataFrame.from_file('/home/zeito/...
Here is how you can do it in R using sp::merge
# read data
p <- shapefile("path/file.shp")
d <- read.csv("path/file.csv")
# merge on common variable, here called 'key'
m <- merge(p, d, by='key')
# perhaps save as shapefile again
The tool you are looking for is Vector > Geoprocessing Tools > Union.
This cuts the input polygon into pieces. Then you can calculate the percentage of individual pieces as area of given piece divided by area of original unit (best to add as attribute beforehand, it will be preserved during Union).