Examples with TIntHashSet gnu.trove.set.hash.TIntHashSet used on opensource projects

Example 31 with TIntHashSet

use of gnu.trove.set.hash.TIntHashSet in project nextprot-api by calipho-sib.

the class IntGraph method getEdgesIncidentTo.

@Override
public int[] getEdgesIncidentTo(int... nodes) {
    TIntSet edges = new TIntHashSet();
    edges.addAll(getInEdges(nodes));
    edges.addAll(getOutEdges(nodes));
    return edges.toArray();
}

Example 32 with TIntHashSet

use of gnu.trove.set.hash.TIntHashSet in project nextprot-api by calipho-sib.

the class IntGraph method getDescendants.

@Override
public int[] getDescendants(int node) {
    TIntSet descendants = new TIntHashSet();
    getDescendants(node, descendants);
    return descendants.toArray();
}

Example 33 with TIntHashSet

use of gnu.trove.set.hash.TIntHashSet in project Osmand by osmandapp.

the class BinaryMapAddressReaderAdapter method searchAddressDataByName.

public void searchAddressDataByName(AddressRegion reg, SearchRequest<MapObject> req, List<Integer> typeFilter) throws IOException {
    TIntArrayList loffsets = new TIntArrayList();
    CollatorStringMatcher stringMatcher = new CollatorStringMatcher(req.nameQuery, req.matcherMode);
    String postcode = Postcode.normalize(req.nameQuery, map.getCountryName());
    final CityMatcher postcodeMatcher = new DefaultCityMatcher(new CollatorStringMatcher(postcode, req.matcherMode));
    final CityMatcher cityMatcher = new DefaultCityMatcher(stringMatcher);
    final CityMatcher cityPostcodeMatcher = new CityMatcher() {

        @Override
        public boolean matches(City city) {
            return city.isPostcode() ? postcodeMatcher.matches(city) : cityMatcher.matches(city);
        }
    };
    long time = System.currentTimeMillis();
    int indexOffset = 0;
    while (true) {
        if (req.isCancelled()) {
            return;
        }
        int t = codedIS.readTag();
        int tag = WireFormat.getTagFieldNumber(t);
        switch(tag) {
            case 0:
                return;
            case OsmAndAddressNameIndexData.TABLE_FIELD_NUMBER:
                int length = readInt();
                indexOffset = codedIS.getTotalBytesRead();
                int oldLimit = codedIS.pushLimit(length);
                // here offsets are sorted by distance
                map.readIndexedStringTable(stringMatcher.getCollator(), req.nameQuery, "", loffsets, 0);
                codedIS.popLimit(oldLimit);
                break;
            case OsmAndAddressNameIndexData.ATOM_FIELD_NUMBER:
                // also offsets can be randomly skipped by limit
                loffsets.sort();
                TIntArrayList[] refs = new TIntArrayList[5];
                TIntArrayList[] refsContainer = new TIntArrayList[5];
                for (int i = 0; i < refs.length; i++) {
                    refs[i] = new TIntArrayList();
                    refsContainer[i] = new TIntArrayList();
                }
                LOG.info("Searched address structure in " + (System.currentTimeMillis() - time) + "ms. Found " + loffsets.size() + " subtress");
                for (int j = 0; j < loffsets.size(); j++) {
                    int fp = indexOffset + loffsets.get(j);
                    codedIS.seek(fp);
                    int len = codedIS.readRawVarint32();
                    int oldLim = codedIS.pushLimit(len);
                    int stag = 0;
                    do {
                        int st = codedIS.readTag();
                        stag = WireFormat.getTagFieldNumber(st);
                        if (stag == AddressNameIndexData.ATOM_FIELD_NUMBER) {
                            int slen = codedIS.readRawVarint32();
                            int soldLim = codedIS.pushLimit(slen);
                            readAddressNameData(req, refs, refsContainer, fp);
                            codedIS.popLimit(soldLim);
                        } else if (stag != 0) {
                            skipUnknownField(st);
                        }
                    } while (stag != 0);
                    codedIS.popLimit(oldLim);
                    if (req.isCancelled()) {
                        return;
                    }
                }
                if (typeFilter == null) {
                    typeFilter = TYPES;
                }
                for (int i = 0; i < typeFilter.size() && !req.isCancelled(); i++) {
                    TIntArrayList list = refs[typeFilter.get(i)];
                    TIntArrayList listContainer = refsContainer[typeFilter.get(i)];
                    if (typeFilter.get(i) == STREET_TYPE) {
                        TIntLongHashMap mp = new TIntLongHashMap();
                        for (int j = 0; j < list.size(); j++) {
                            mp.put(list.get(j), listContainer.get(j));
                        }
                        list.sort();
                        for (int j = 0; j < list.size() && !req.isCancelled(); j++) {
                            int offset = list.get(j);
                            if (j > 0 && offset == list.get(j - 1)) {
                                continue;
                            }
                            City obj;
                            {
                                int contOffset = (int) mp.get(offset);
                                codedIS.seek(contOffset);
                                int len = codedIS.readRawVarint32();
                                int old = codedIS.pushLimit(len);
                                obj = readCityHeader(null, contOffset, reg.attributeTagsTable);
                                codedIS.popLimit(old);
                            }
                            if (obj != null) {
                                codedIS.seek(offset);
                                int len = codedIS.readRawVarint32();
                                int old = codedIS.pushLimit(len);
                                LatLon l = obj.getLocation();
                                Street s = new Street(obj);
                                s.setFileOffset(offset);
                                readStreet(s, null, false, MapUtils.get31TileNumberX(l.getLongitude()) >> 7, MapUtils.get31TileNumberY(l.getLatitude()) >> 7, obj.isPostcode() ? obj.getName() : null, reg.attributeTagsTable);
                                boolean matches = stringMatcher.matches(s.getName());
                                if (!matches) {
                                    for (String n : s.getAllNames()) {
                                        matches = stringMatcher.matches(n);
                                        if (matches) {
                                            break;
                                        }
                                    }
                                }
                                if (matches) {
                                    req.publish(s);
                                }
                                codedIS.popLimit(old);
                            }
                        }
                    } else {
                        list.sort();
                        TIntSet published = new TIntHashSet();
                        for (int j = 0; j < list.size() && !req.isCancelled(); j++) {
                            int offset = list.get(j);
                            if (j > 0 && offset == list.get(j - 1)) {
                                continue;
                            }
                            codedIS.seek(offset);
                            int len = codedIS.readRawVarint32();
                            int old = codedIS.pushLimit(len);
                            City obj = readCityHeader(cityPostcodeMatcher, list.get(j), reg.attributeTagsTable);
                            if (obj != null && !published.contains(offset)) {
                                req.publish(obj);
                                published.add(offset);
                            }
                            codedIS.popLimit(old);
                        }
                    }
                }
                LOG.info("Whole address search by name is done in " + (System.currentTimeMillis() - time) + "ms. Found " + req.getSearchResults().size());
                return;
            default:
                skipUnknownField(t);
                break;
        }
    }
}

Example 34 with TIntHashSet

use of gnu.trove.set.hash.TIntHashSet in project Osmand by osmandapp.

the class BinaryMapIndexFilter method process.

private Stat process(final int zoom) throws IOException {
    final Stat stat = new Stat();
    final Map<TagValuePair, Integer> map = new HashMap<TagValuePair, Integer>();
    SearchFilter sf = new SearchFilter() {

        @Override
        public boolean accept(TIntArrayList types, MapIndex index) {
            boolean polygon = false;
            boolean polyline = false;
            for (int j = 0; j < types.size(); j++) {
                int wholeType = types.get(j);
                TagValuePair pair = index.decodeType(wholeType);
                if (pair != null) {
                    int t = wholeType & 3;
                    if (t == RenderingRulesStorage.POINT_RULES) {
                        stat.pointCount++;
                    } else if (t == RenderingRulesStorage.LINE_RULES) {
                        stat.wayCount++;
                        polyline = true;
                    } else {
                        polygon = true;
                        stat.polygonCount++;
                        if (!map.containsKey(pair)) {
                            map.put(pair, 0);
                        }
                        map.put(pair, map.get(pair) + 1);
                    }
                }
            }
            stat.totalCount++;
            return polyline;
        }
    };
    ResultMatcher<BinaryMapDataObject> matcher = new ResultMatcher<BinaryMapDataObject>() {

        TIntHashSet set = new TIntHashSet();

        @Override
        public boolean isCancelled() {
            return false;
        }

        @Override
        public boolean publish(BinaryMapDataObject object) {
            // double area = calculateArea(object, zoom);
            double len = calculateLength(object, zoom);
            if (/*tilesCovers(object, zoom, set) >= 2  && */
            len > 100) {
                stat.polygonBigSize++;
                if (stat.polygonBigSize % 10000 == 0) {
                    return true;
                }
            }
            return false;
        }
    };
    SearchRequest<BinaryMapDataObject> req = BinaryMapIndexReader.buildSearchRequest(0, Integer.MAX_VALUE, 0, Integer.MAX_VALUE, zoom, sf, matcher);
    List<BinaryMapDataObject> result = reader.searchMapIndex(req);
    ArrayList<TagValuePair> list = new ArrayList<TagValuePair>(map.keySet());
    Collections.sort(list, new Comparator<TagValuePair>() {

        @Override
        public int compare(TagValuePair o1, TagValuePair o2) {
            return -map.get(o1) + map.get(o2);
        }
    });
    for (TagValuePair tp : list) {
        Integer i = map.get(tp);
        if (i > 10) {
        // System.out.println(tp.toString() + " " + i);
        }
    }
    for (BinaryMapDataObject obj : result) {
        System.out.println("id " + (obj.getId() >> 3) + " " + calculateArea(obj, zoom));
    }
    return stat;
}

Example 35 with TIntHashSet

use of gnu.trove.set.hash.TIntHashSet in project Osmand by osmandapp.

the class RouteResultPreparation method inferSlightTurnFromLanes.

private int inferSlightTurnFromLanes(int[] oLanes, RoadSplitStructure rs) {
    TIntHashSet possibleTurns = new TIntHashSet();
    for (int i = 0; i < oLanes.length; i++) {
        if ((oLanes[i] & 1) == 0) {
            continue;
        }
        if (possibleTurns.isEmpty()) {
            // Nothing is in the list to compare to, so add the first elements
            possibleTurns.add(TurnType.getPrimaryTurn(oLanes[i]));
            if (TurnType.getSecondaryTurn(oLanes[i]) != 0) {
                possibleTurns.add(TurnType.getSecondaryTurn(oLanes[i]));
            }
            if (TurnType.getTertiaryTurn(oLanes[i]) != 0) {
                possibleTurns.add(TurnType.getTertiaryTurn(oLanes[i]));
            }
        } else {
            TIntArrayList laneTurns = new TIntArrayList();
            laneTurns.add(TurnType.getPrimaryTurn(oLanes[i]));
            if (TurnType.getSecondaryTurn(oLanes[i]) != 0) {
                laneTurns.add(TurnType.getSecondaryTurn(oLanes[i]));
            }
            if (TurnType.getTertiaryTurn(oLanes[i]) != 0) {
                laneTurns.add(TurnType.getTertiaryTurn(oLanes[i]));
            }
            possibleTurns.retainAll(laneTurns);
            if (possibleTurns.isEmpty()) {
                // No common turns, so can't determine anything.
                return 0;
            }
        }
    }
    // Remove all turns from lanes not selected...because those aren't it
    for (int i = 0; i < oLanes.length; i++) {
        if ((oLanes[i] & 1) == 0 && !possibleTurns.isEmpty()) {
            possibleTurns.remove((Integer) TurnType.getPrimaryTurn(oLanes[i]));
            if (TurnType.getSecondaryTurn(oLanes[i]) != 0) {
                possibleTurns.remove((Integer) TurnType.getSecondaryTurn(oLanes[i]));
            }
            if (TurnType.getTertiaryTurn(oLanes[i]) != 0) {
                possibleTurns.remove((Integer) TurnType.getTertiaryTurn(oLanes[i]));
            }
        }
    }
    // remove all non-slight turns // TEST don't pass
    // if(possibleTurns.size() > 1) {
    // TIntIterator it = possibleTurns.iterator();
    // while(it.hasNext()) {
    // int nxt = it.next();
    // if(!TurnType.isSlightTurn(nxt)) {
    // it.remove();
    // }
    // }
    // }
    int infer = 0;
    if (possibleTurns.size() == 1) {
        infer = possibleTurns.iterator().next();
    } else if (possibleTurns.size() > 1) {
        if (rs.keepLeft && rs.keepRight && possibleTurns.contains(TurnType.C)) {
            infer = TurnType.C;
        } else if (rs.keepLeft || rs.keepRight) {
            TIntIterator it = possibleTurns.iterator();
            infer = it.next();
            while (it.hasNext()) {
                int next = it.next();
                int orderInfer = TurnType.orderFromLeftToRight(infer);
                int orderNext = TurnType.orderFromLeftToRight(next);
                if (rs.keepLeft && orderNext < orderInfer) {
                    infer = next;
                } else if (rs.keepRight && orderNext > orderInfer) {
                    infer = next;
                }
            }
        }
    }
    // Checking to see that there is only one unique turn
    if (infer != 0) {
        for (int i = 0; i < oLanes.length; i++) {
            if (TurnType.getSecondaryTurn(oLanes[i]) == infer) {
                int pt = TurnType.getPrimaryTurn(oLanes[i]);
                int en = oLanes[i] & 1;
                TurnType.setPrimaryTurnAndReset(oLanes, i, infer);
                oLanes[i] |= en;
                TurnType.setSecondaryTurn(oLanes, i, pt);
            }
        }
    }
    return infer;
}