Examples with RouteRegion net.osmand.binary.BinaryMapRouteReaderAdapter.RouteRegion used on opensource projects

Example 16 with RouteRegion

use of net.osmand.binary.BinaryMapRouteReaderAdapter.RouteRegion in project Osmand by osmandapp.

the class BinaryInspector method combineParts.

@SuppressWarnings("unchecked")
public static List<Float> combineParts(File fileToExtract, Map<File, String> partsToExtractFrom) throws IOException {
    BinaryMapIndexReader[] indexes = new BinaryMapIndexReader[partsToExtractFrom.size()];
    RandomAccessFile[] rafs = new RandomAccessFile[partsToExtractFrom.size()];
    LinkedHashSet<Float>[] partsSet = new LinkedHashSet[partsToExtractFrom.size()];
    int c = 0;
    Set<String> addressNames = new LinkedHashSet<String>();
    int version = -1;
    // Go through all files and validate conistency
    for (File f : partsToExtractFrom.keySet()) {
        if (f.getAbsolutePath().equals(fileToExtract.getAbsolutePath())) {
            System.err.println("Error : Input file is equal to output file " + f.getAbsolutePath());
            return null;
        }
        rafs[c] = new RandomAccessFile(f.getAbsolutePath(), "r");
        indexes[c] = new BinaryMapIndexReader(rafs[c], f);
        partsSet[c] = new LinkedHashSet<Float>();
        if (version == -1) {
            version = indexes[c].getVersion();
        } else {
            if (indexes[c].getVersion() != version) {
                System.err.println("Error : Different input files has different input versions " + indexes[c].getVersion() + " != " + version);
                return null;
            }
        }
        LinkedHashSet<Float> temp = new LinkedHashSet<Float>();
        String pattern = partsToExtractFrom.get(f);
        boolean minus = true;
        for (int i = 0; i < indexes[c].getIndexes().size(); i++) {
            partsSet[c].add(i + 1f);
            BinaryIndexPart part = indexes[c].getIndexes().get(i);
            if (part instanceof MapIndex) {
                List<MapRoot> roots = ((MapIndex) part).getRoots();
                int rsize = roots.size();
                for (int j = 0; j < rsize; j++) {
                    partsSet[c].add((i + 1f) + (j + 1) / 10f);
                }
            }
        }
        if (pattern != null) {
            minus = pattern.startsWith("-");
            String[] split = pattern.substring(1).split(",");
            for (String s : split) {
                temp.add(Float.valueOf(s));
            }
        }
        Iterator<Float> p = partsSet[c].iterator();
        while (p.hasNext()) {
            Float part = p.next();
            if (minus) {
                if (temp.contains(part)) {
                    p.remove();
                }
            } else {
                if (!temp.contains(part)) {
                    p.remove();
                }
            }
        }
        c++;
    }
    // write files
    FileOutputStream fout = new FileOutputStream(fileToExtract);
    CodedOutputStream ous = CodedOutputStream.newInstance(fout, BUFFER_SIZE);
    List<Float> list = new ArrayList<Float>();
    byte[] BUFFER_TO_READ = new byte[BUFFER_SIZE];
    ous.writeInt32(OsmandOdb.OsmAndStructure.VERSION_FIELD_NUMBER, version);
    ous.writeInt64(OsmandOdb.OsmAndStructure.DATECREATED_FIELD_NUMBER, System.currentTimeMillis());
    for (int k = 0; k < indexes.length; k++) {
        LinkedHashSet<Float> partSet = partsSet[k];
        BinaryMapIndexReader index = indexes[k];
        RandomAccessFile raf = rafs[k];
        for (int i = 0; i < index.getIndexes().size(); i++) {
            if (!partSet.contains(Float.valueOf(i + 1f))) {
                continue;
            }
            list.add(i + 1f);
            BinaryIndexPart part = index.getIndexes().get(i);
            String map;
            if (part instanceof MapIndex) {
                ous.writeTag(OsmandOdb.OsmAndStructure.MAPINDEX_FIELD_NUMBER, WireFormat.WIRETYPE_FIXED32_LENGTH_DELIMITED);
                map = "Map";
            } else if (part instanceof AddressRegion) {
                ous.writeTag(OsmandOdb.OsmAndStructure.ADDRESSINDEX_FIELD_NUMBER, WireFormat.WIRETYPE_FIXED32_LENGTH_DELIMITED);
                map = "Address";
                if (addressNames.contains(part.getName())) {
                    System.err.println("Error : going to merge 2 addresses with same names. Skip " + part.getName());
                    continue;
                }
                addressNames.add(part.getName());
            } else if (part instanceof TransportIndex) {
                ous.writeTag(OsmandOdb.OsmAndStructure.TRANSPORTINDEX_FIELD_NUMBER, WireFormat.WIRETYPE_FIXED32_LENGTH_DELIMITED);
                map = "Transport";
            } else if (part instanceof PoiRegion) {
                ous.writeTag(OsmandOdb.OsmAndStructure.POIINDEX_FIELD_NUMBER, WireFormat.WIRETYPE_FIXED32_LENGTH_DELIMITED);
                map = "POI";
            } else if (part instanceof RouteRegion) {
                ous.writeTag(OsmandOdb.OsmAndStructure.ROUTINGINDEX_FIELD_NUMBER, WireFormat.WIRETYPE_FIXED32_LENGTH_DELIMITED);
                map = "Routing";
            } else {
                throw new UnsupportedOperationException();
            }
            writeInt(ous, part.getLength());
            copyBinaryPart(ous, BUFFER_TO_READ, raf, part.getFilePointer(), part.getLength());
            System.out.println(MessageFormat.format("{2} part {0} is extracted {1} bytes", new Object[] { part.getName(), part.getLength(), map }));
        }
    }
    ous.writeInt32(OsmandOdb.OsmAndStructure.VERSIONCONFIRM_FIELD_NUMBER, version);
    ous.flush();
    fout.close();
    return list;
}

Example 17 with RouteRegion

use of net.osmand.binary.BinaryMapRouteReaderAdapter.RouteRegion in project Osmand by osmandapp.

the class BinaryMapIndexReader method init.

private void init() throws IOException {
    boolean initCorrectly = false;
    while (true) {
        int t = codedIS.readTag();
        int tag = WireFormat.getTagFieldNumber(t);
        switch(tag) {
            case 0:
                if (!initCorrectly) {
                    // $NON-NLS-1$
                    throw new IOException("Corrupt file, it should have ended as it starts with version: " + file.getName());
                }
                return;
            case OsmandOdb.OsmAndStructure.VERSION_FIELD_NUMBER:
                version = codedIS.readUInt32();
                break;
            case OsmandOdb.OsmAndStructure.DATECREATED_FIELD_NUMBER:
                dateCreated = codedIS.readInt64();
                break;
            case OsmandOdb.OsmAndStructure.MAPINDEX_FIELD_NUMBER:
                MapIndex mapIndex = new MapIndex();
                mapIndex.length = readInt();
                mapIndex.filePointer = codedIS.getTotalBytesRead();
                int oldLimit = codedIS.pushLimit(mapIndex.length);
                readMapIndex(mapIndex, false);
                basemap = basemap || mapIndex.isBaseMap();
                codedIS.popLimit(oldLimit);
                codedIS.seek(mapIndex.filePointer + mapIndex.length);
                mapIndexes.add(mapIndex);
                indexes.add(mapIndex);
                break;
            case OsmandOdb.OsmAndStructure.ADDRESSINDEX_FIELD_NUMBER:
                AddressRegion region = new AddressRegion();
                region.length = readInt();
                region.filePointer = codedIS.getTotalBytesRead();
                if (addressAdapter != null) {
                    oldLimit = codedIS.pushLimit(region.length);
                    addressAdapter.readAddressIndex(region);
                    if (region.name != null) {
                        addressIndexes.add(region);
                        indexes.add(region);
                    }
                    codedIS.popLimit(oldLimit);
                }
                codedIS.seek(region.filePointer + region.length);
                break;
            case OsmandOdb.OsmAndStructure.TRANSPORTINDEX_FIELD_NUMBER:
                TransportIndex ind = new TransportIndex();
                ind.length = readInt();
                ind.filePointer = codedIS.getTotalBytesRead();
                if (transportAdapter != null) {
                    oldLimit = codedIS.pushLimit(ind.length);
                    transportAdapter.readTransportIndex(ind);
                    codedIS.popLimit(oldLimit);
                    transportIndexes.add(ind);
                    indexes.add(ind);
                }
                codedIS.seek(ind.filePointer + ind.length);
                break;
            case OsmandOdb.OsmAndStructure.ROUTINGINDEX_FIELD_NUMBER:
                RouteRegion routeReg = new RouteRegion();
                routeReg.length = readInt();
                routeReg.filePointer = codedIS.getTotalBytesRead();
                if (routeAdapter != null) {
                    oldLimit = codedIS.pushLimit(routeReg.length);
                    routeAdapter.readRouteIndex(routeReg);
                    codedIS.popLimit(oldLimit);
                    routingIndexes.add(routeReg);
                    indexes.add(routeReg);
                }
                codedIS.seek(routeReg.filePointer + routeReg.length);
                break;
            case OsmandOdb.OsmAndStructure.POIINDEX_FIELD_NUMBER:
                PoiRegion poiInd = new PoiRegion();
                poiInd.length = readInt();
                poiInd.filePointer = codedIS.getTotalBytesRead();
                if (poiAdapter != null) {
                    oldLimit = codedIS.pushLimit(poiInd.length);
                    poiAdapter.readPoiIndex(poiInd, false);
                    codedIS.popLimit(oldLimit);
                    poiIndexes.add(poiInd);
                    indexes.add(poiInd);
                }
                codedIS.seek(poiInd.filePointer + poiInd.length);
                break;
            case OsmandOdb.OsmAndStructure.VERSIONCONFIRM_FIELD_NUMBER:
                int cversion = codedIS.readUInt32();
                calculateCenterPointForRegions();
                initCorrectly = cversion == version;
                break;
            default:
                skipUnknownField(t);
                break;
        }
    }
}

Example 18 with RouteRegion

use of net.osmand.binary.BinaryMapRouteReaderAdapter.RouteRegion in project Osmand by osmandapp.

the class CurrentPositionHelper method justifyResult.

private void justifyResult(List<GeocodingResult> res, final ResultMatcher<GeocodingResult> result) {
    List<GeocodingResult> complete = new ArrayList<>();
    double minBuildingDistance = 0;
    if (res != null) {
        for (GeocodingResult r : res) {
            BinaryMapIndexReader foundRepo = null;
            List<BinaryMapReaderResource> rts = usedReaders;
            for (BinaryMapReaderResource rt : rts) {
                if (rt.isClosed()) {
                    continue;
                }
                BinaryMapIndexReader reader = rt.getReader(BinaryMapReaderResourceType.STREET_LOOKUP);
                for (RouteRegion rb : reader.getRoutingIndexes()) {
                    if (r.regionFP == rb.getFilePointer() && r.regionLen == rb.getLength()) {
                        foundRepo = reader;
                        break;
                    }
                }
            }
            if (result.isCancelled()) {
                break;
            } else if (foundRepo != null) {
                List<GeocodingResult> justified = null;
                try {
                    justified = new GeocodingUtilities().justifyReverseGeocodingSearch(r, foundRepo, minBuildingDistance, result);
                } catch (IOException e) {
                    log.error("Exception happened during reverse geocoding", e);
                    e.printStackTrace();
                }
                if (justified != null && !justified.isEmpty()) {
                    double md = justified.get(0).getDistance();
                    if (minBuildingDistance == 0) {
                        minBuildingDistance = md;
                    } else {
                        minBuildingDistance = Math.min(md, minBuildingDistance);
                    }
                    complete.addAll(justified);
                }
            } else {
                complete.add(r);
            }
        }
    }
    if (result.isCancelled()) {
        app.runInUIThread(new Runnable() {

            public void run() {
                result.publish(null);
            }
        });
        return;
    }
    Collections.sort(complete, GeocodingUtilities.DISTANCE_COMPARATOR);
    // for(GeocodingResult rt : complete) {
    // System.out.println(rt.toString());
    // }
    final GeocodingResult rts = complete.size() > 0 ? complete.get(0) : new GeocodingResult();
    app.runInUIThread(new Runnable() {

        public void run() {
            result.publish(rts);
        }
    });
}

Example 19 with RouteRegion

use of net.osmand.binary.BinaryMapRouteReaderAdapter.RouteRegion in project Osmand by osmandapp.

the class RouteCalculationResult method attachAlarmInfo.

private static void attachAlarmInfo(List<AlarmInfo> alarms, RouteSegmentResult res, int intId, int locInd) {
    int[] pointTypes = res.getObject().getPointTypes(intId);
    if (pointTypes != null) {
        RouteRegion reg = res.getObject().region;
        for (int r = 0; r < pointTypes.length; r++) {
            RouteTypeRule typeRule = reg.quickGetEncodingRule(pointTypes[r]);
            int x31 = res.getObject().getPoint31XTile(intId);
            int y31 = res.getObject().getPoint31YTile(intId);
            Location loc = new Location("");
            loc.setLatitude(MapUtils.get31LatitudeY(y31));
            loc.setLongitude(MapUtils.get31LongitudeX(x31));
            AlarmInfo info = AlarmInfo.createAlarmInfo(typeRule, locInd, loc);
            // For STOP first check if it has directional info
            if ((info != null) && !((info.getType() == AlarmInfoType.STOP) && !res.getObject().isStopApplicable(res.isForwardDirection(), intId, res.getStartPointIndex(), res.getEndPointIndex()))) {
                alarms.add(info);
            }
        }
    }
}

Example 20 with RouteRegion

use of net.osmand.binary.BinaryMapRouteReaderAdapter.RouteRegion in project Osmand by osmandapp.

the class MapRenderRepositories method readRouteDataAsMapObjects.

private void readRouteDataAsMapObjects(SearchRequest<BinaryMapDataObject> sr, BinaryMapIndexReader c, final ArrayList<BinaryMapDataObject> tempResult, final TLongSet ids) {
    final boolean basemap = c.isBasemap();
    try {
        for (RouteRegion reg : c.getRoutingIndexes()) {
            List<RouteSubregion> parent = sr.getZoom() < 15 ? reg.getBaseSubregions() : reg.getSubregions();
            List<RouteSubregion> searchRouteIndexTree = c.searchRouteIndexTree(sr, parent);
            final MapIndex nmi = new MapIndex();
            c.loadRouteIndexData(searchRouteIndexTree, new ResultMatcher<RouteDataObject>() {

                @Override
                public boolean publish(RouteDataObject r) {
                    if (basemap) {
                        renderedState |= 1;
                    } else {
                        renderedState |= 2;
                    }
                    if (checkForDuplicateObjectIds && !basemap) {
                        if (ids.contains(r.getId()) && r.getId() > 0) {
                            // do not add object twice
                            return false;
                        }
                        ids.add(r.getId());
                    }
                    int[] coordinantes = new int[r.getPointsLength() * 2];
                    int[] roTypes = r.getTypes();
                    for (int k = 0; k < roTypes.length; k++) {
                        int type = roTypes[k];
                        registerMissingType(nmi, r, type);
                    }
                    for (int k = 0; k < coordinantes.length / 2; k++) {
                        coordinantes[2 * k] = r.getPoint31XTile(k);
                        coordinantes[2 * k + 1] = r.getPoint31YTile(k);
                    }
                    BinaryMapDataObject mo = new BinaryMapDataObject(r.getId(), coordinantes, new int[0][], RenderingRulesStorage.LINE_RULES, true, roTypes, null);
                    TIntObjectHashMap<String> names = r.getNames();
                    if (names != null) {
                        TIntObjectIterator<String> it = names.iterator();
                        while (it.hasNext()) {
                            it.advance();
                            registerMissingType(nmi, r, it.key());
                            mo.putObjectName(it.key(), it.value());
                        }
                    }
                    mo.setMapIndex(nmi);
                    tempResult.add(mo);
                    return false;
                }

                private void registerMissingType(final MapIndex nmi, RouteDataObject r, int type) {
                    if (!nmi.isRegisteredRule(type)) {
                        RouteTypeRule rr = r.region.quickGetEncodingRule(type);
                        String tag = rr.getTag();
                        int additional = ("highway".equals(tag) || "route".equals(tag) || "railway".equals(tag) || "aeroway".equals(tag) || "aerialway".equals(tag)) ? 0 : 1;
                        nmi.initMapEncodingRule(additional, type, rr.getTag(), rr.getValue());
                    }
                }

                @Override
                public boolean isCancelled() {
                    return !interrupted;
                }
            });
        }
    } catch (IOException e) {
        // $NON-NLS-1$
        log.debug("Search failed " + c.getRegionNames(), e);
    }
}