示例#1
0
func (ex *Excavator) dredge() {
	util.Info("Starting dredger")
	defer ex.dredgers.Done()
	for {
		if val, err := ex.pbf.Decode(); err == io.EOF {
			break
		} else if err != nil {
			ex.errs <- err
			break
		} else {
			switch val := val.(type) {
			case *osmpbf.Node:
				o := &Node{val}
				if o.Valid() {
					ex.nodes <- o
				}
			case *osmpbf.Way:
				o := &Way{val}
				if o.Valid() {
					ex.ways <- o
				}
			case *osmpbf.Relation:
				ex.relations <- &Relation{val}
			default:
				ex.errs <- util.Errorf("Unknown OSM Type %T %v", val, val)
			}
		}
	}
	util.Info("Closing dredger")
}
示例#2
0
文件: shape.go 项目: buckhx/diglet
func NewBox(min, max Coordinate) (box Box, err error) {
	if min.Lat > max.Lat || min.Lon > max.Lon {
		err = util.Errorf("Min %v > Max %v", min, max)
	} else {
		box = Box{min: min, max: max}
	}
	return
}
示例#3
0
文件: shape.go 项目: buckhx/diglet
func (s *Shape) Insert(i int, p Point) (err error) {
	if i >= len(s.points) || i < 0 {
		return util.Errorf("Insert index out of range %v @ %d", s.points, i)
	} else {
		a := s.points
		s.points = append(a[:i], append([]Point{p}, a[i:]...)...)
		//s.points[i] = p
	}
	return
}
示例#4
0
文件: csv.go 项目: buckhx/diglet
func (c *CsvSource) featureAdapter(line []string) (feature *geo.Feature, err error) {
	props := make(map[string]interface{}, len(c.headers)) //biggest malloc
	for k, i := range c.headers {
		props[k] = line[i]
	}
	switch {
	case c.fields.HasCoordinates():
		feature = geo.NewPointFeature()
		feature.Properties = props
		lat, err := strconv.ParseFloat(line[c.headers[c.fields["lat"]]], 64)
		if err != nil {
			return nil, err
		}
		lon, err := strconv.ParseFloat(line[c.headers[c.fields["lon"]]], 64)
		if err != nil {
			return nil, err
		}
		point := geo.NewShape(geo.Coordinate{Lat: lat, Lon: lon})
		feature.AddShape(point)
	case c.fields.HasShape():
		g := line[c.headers[c.fields["shape"]]]
		shp, err := geo.ShapeFromString(g)
		if err != nil {
			return nil, util.Errorf("Invalid shape format %+v", g)
		}
		switch {
		case len(shp.Coordinates) == 0:
			feature = geo.NewPointFeature()
		case len(shp.Coordinates) == 1:
			feature = geo.NewPointFeature()
		case shp.Coordinates[0] == shp.Coordinates[len(shp.Coordinates)-1]: //closed
			feature = geo.NewPolygonFeature()
		default:
			feature = geo.NewLineFeature()
		}
		feature.Properties = props
		feature.AddShape(shp)
	default:
		err = util.Errorf("Invalid line")
	}
	return
}
示例#5
0
文件: geometry.go 项目: buckhx/diglet
func flushCommands(chunk []*command) (geom []uint32, err error) {
	if len(chunk) < 1 {
		err = util.Errorf("Flushing Zero-Length command chunk")
	} else {
		cid := chunk[0].cid
		cnt := uint(len(chunk))
		cint := writeCmdInt(cid, cnt)
		geom = append(geom, cint)
		for _, cmd := range chunk {
			if cmd.cid != cid {
				msg := "Non contiguous CommandInteger in command chunk: %v"
				err = util.Errorf(msg, chunk)
				return
			}
			for _, param := range cmd.params {
				pint := writePrmInt(param)
				geom = append(geom, pint)
			}
		}
	}
	return
}
示例#6
0
文件: cmd.go 项目: buckhx/diglet
func getSource(c *cli.Context) (source FeatureSource, err error) {
	path := c.Args()[0]
	var filter []string
	if len(c.String("filter")) > 0 {
		filter = strings.Split(c.String("filter"), ",")
	}
	ext := filepath.Ext(path)[1:]
	switch ext {
	case CsvExt:
		delim := c.String("csv-delimiter")
		fields := GeoFields{"lat": c.String("csv-lat"), "lon": c.String("csv-lon"), "shape": c.String("csv-shape")}
		if !fields.Validate() {
			err = util.Errorf("csv-lat/csv-lon or csv-shape required")
			break
		}
		source = NewCsvSource(path, filter, delim, fields)
	case GeojsonExt:
		source = NewGeojsonSource(path, filter)
	default:
		err = util.Errorf("Invalid source file extension %s %s", ext, strings.Join(exts, "|"))
	}
	return
}
示例#7
0
文件: shape.go 项目: buckhx/diglet
// [[lon,lat]...]
func ShapeFromString(raw string) (shp *Shape, err error) {
	var points [][]float64
	err = json.Unmarshal([]byte(raw), &points)
	if err != nil {
		return
	}
	shp = MakeShape(len(points))
	for i, p := range points {
		if len(p) != 2 {
			shp = nil
			err = util.Errorf("Coordinate string len != 2 @ %d %s", i, raw)
			return
		}
		shp.Coordinates[i] = Coordinate{Lat: p[1], Lon: p[0]}
	}
	return
}
示例#8
0
文件: geometry.go 项目: buckhx/diglet
func vtShapes(geom []uint32) (shapes []*Shape, gtype vt.Tile_GeomType, err error) {
	cur := Point{X: 0, Y: 0}
	blocks := vtCommands(geom)
	shapes = make([]*Shape, len(blocks))
	for i, commands := range blocks {
		length := len(commands)
		if commands[len(commands)-1].cid == ClosePath {
			length--
		}
		shape := MakeShape(length)
		shapes[i] = shape
		for c, cmd := range commands {
			switch cmd.cid {
			case MoveTo:
				x := cmd.params[0]
				y := cmd.params[1]
				cur = cur.Increment(x, y)
				shape.points[c] = cur
				gtype = vt.Tile_POINT
				//shape := NewPointShape(cur)
				//shapes[i] = shape
				//i++
			case LineTo:
				x := cmd.params[0]
				y := cmd.params[1]
				cur = cur.Increment(x, y)
				shape.points[c] = cur
				gtype = vt.Tile_LINESTRING
				//shape := shapes[i-1]
				//shape.Append(cur)
			case ClosePath:
				gtype = vt.Tile_POLYGON
				//shape := shapes[len(shapes)-1]
				//start := shape.points[0]
				//shape.Append(start)
			default:
				err = util.Errorf("Invalid CommandInteger %d", cmd.cid)
				break
			}
		}
	}
	return
}
示例#9
0
文件: layer.go 项目: buckhx/diglet
func getVtValue(val interface{}) (vt_val *vt.Tile_Value) {
	vt_val = &vt.Tile_Value{}
	switch v := val.(type) {
	case string:
		vt_val.StringValue = &v
	case float32:
		vt_val.FloatValue = &v
	case float64:
		vt_val.DoubleValue = &v
	case int:
		intv := int64(v)
		vt_val.IntValue = &intv
	case int32:
		intv := int64(v)
		vt_val.IntValue = &intv
	case int64:
		vt_val.IntValue = &v
	case uint:
		uintv := uint64(v)
		vt_val.UintValue = &uintv
	case uint32:
		uintv := uint64(v)
		vt_val.UintValue = &uintv
	case uint64:
		vt_val.UintValue = &v
	case bool:
		vt_val.BoolValue = &v
	case nil:
		// nothing
	default:
		//TODO, flatten maps
		err := util.Errorf("Bad interface{} for vt.Tile_Value  %v", val)
		util.Warn(err, "attempting to cast value to json string")
		if b, err := json.Marshal(v); err == nil {
			s := string(b)
			vt_val.StringValue = &s
		} else {
			util.Warn(err, "json cast failed, skipping...")
		}
	}
	return
}
示例#10
0
文件: geojson.go 项目: buckhx/diglet
// Flatten all the points of a feature into single list. This can hel in identifying which tiles are going to be
// created
func GeojsonFeatureAdapter(gj *geojson.Feature) (feature *Feature, err error) {
	// TODO: This sucks... I just want to switch on Coordinates.(type)
	igeom, err := gj.GetGeometry()
	if igeom == nil || err != nil {
		err = util.Errorf("Invalid geojson feature %q", gj)
		return
	}
	feature = NewFeature(igeom.GetType())
	//TODO filter properties
	feature.Properties = gj.Properties
	if feature.Properties != nil {
		feature.Properties["id"] = gj.Id
	}
	//TODO if id == nil assign a fake one
	feature.Type = igeom.GetType()
	switch geom := igeom.(type) {
	case *geojson.Point:
		shape := coordinatesAdapter(geojson.Coordinates{geom.Coordinates})
		feature.AddShape(shape)
	case *geojson.LineString:
		shape := coordinatesAdapter(geom.Coordinates)
		feature.AddShape(shape)
	case *geojson.MultiPoint:
		shape := coordinatesAdapter(geom.Coordinates)
		feature.AddShape(shape)
	case *geojson.MultiLineString:
		for _, line := range geom.Coordinates {
			shape := coordinatesAdapter(line)
			feature.AddShape(shape)
		}
	case *geojson.Polygon:
		// mvt need exterior ring to be clockwise
		// and interior rings to counter-clockwise
		exterior := true
		for _, line := range geom.Coordinates {
			shape := coordinatesAdapter(line)
			if exterior {
				if !shape.IsClockwise() {
					shape.Reverse()
				}
				exterior = false
			} else {
				if shape.IsClockwise() {
					shape.Reverse()
				}
			}
			feature.AddShape(shape)
		}
	case *geojson.MultiPolygon:
		for _, multiline := range geom.Coordinates {
			exterior := true
			for _, line := range multiline {
				shape := coordinatesAdapter(line)
				if exterior {
					if !shape.IsClockwise() {
						shape.Reverse()
					}
					exterior = false
				} else {
					if shape.IsClockwise() {
						shape.Reverse()
					}
				}
				feature.AddShape(shape)
			}
		}
	default:
		feature = nil

		err = util.Errorf("Invalid Coordinate Type in GeoJson %q", geom)
	}
	return
}