Load the RTree Spatial Index Values

@param featureTable
feature table
321093
public void loadRTreeIndex(FeatureTable featureTable) {
		loadRTreeIndex(featureTable.getTableName(), featureTable
				.getGeometryColumn().getName(), featureTable.getPkColumn()
				.getName());
	}
302520
function(id, geometry, style, featureId) {
        style = this.applyDefaultSymbolizer(style);
        // Get the node if it's already on the map.
        var node = this.nodeFactory(id, this.getNodeType(geometry, style));
        
        // Set the data for the node, then draw it.
        node._featureId = featureId;
        node._boundsBottom = geometry.getBounds().bottom;
        node._geometryClass = geometry.CLASS_NAME;
        node._style = style;

        var drawResult = this.drawGeometryNode(node, geometry, style);
        if(drawResult === false) {
            return false;
        }
         
        node = drawResult.node;
        
        // Insert the node into the indexer so it can show us where to
        // place it. Note that this operation is O(log(n)). If there's a
        // performance problem (when dragging, for instance) this is
        // likely where it would be.
        if (this.indexer) {
            var insert = this.indexer.insert(node);
            if (insert) {
                this.vectorRoot.insertBefore(node, insert);
            } else {
                this.vectorRoot.appendChild(node);
            }
        } else {
            // if there's no indexer, simply append the node to root,
            // but only if the node is a new one
            if (node.parentNode !== this.vectorRoot){ 
                this.vectorRoot.appendChild(node);
            }
        }
        
        this.postDraw(node);
        
        return drawResult.complete;
    }
1165015
public int getIndex(String feature)
	{
		//logger.debug("FeatureIndex.get : " + feature + "(" + count + ")");
		Integer index = (Integer) map.get(feature);

		if (index == null)
			return -1;

		return index.intValue();
	}
897359
static public LinkedHashMap<String,FeatureList> buildFeatureAtrributeIndex(String attribute,FeatureList list){

		LinkedHashMap<String,FeatureList> featureHashMap = new LinkedHashMap<String,FeatureList>();
		FeatureList featureList = list.selectByAttribute(attribute);
		for(FeatureI feature : featureList){
			String value = feature.getAttribute(attribute);
			FeatureList features = featureHashMap.get(value);
			if(features == null){
				features = new FeatureList();
				featureHashMap.put(value, features);
			}
			features.add(feature);
		}

		return featureHashMap;
	}
596102
public void getTablesAndIndexes(Map<String, StmtTargetTableScan> tablesRead,
            Collection<String> indexes)
    {
        for (AbstractPlanNode node : m_inlineNodes.values()) {
            node.getTablesAndIndexes(tablesRead, indexes);
        }
        for (AbstractPlanNode node : m_children) {
            node.getTablesAndIndexes(tablesRead, indexes);
        }
        getTablesAndIndexesFromSubqueries(tablesRead, indexes);
    }
316736
def loadFeatures(self, path_to_fc):
        
        from ..common.spatial import featureclass_to_json
        v = json.loads(featureclass_to_json(path_to_fc))
        self.value = v
1011041
public static Dataset<String, String> readSVMLightFormat(String filename, Index<String> featureIndex, Index<String> labelIndex, List<String> lines) {
    Dataset<String, String> dataset;
    try {
      dataset = new Dataset<String, String>(10, featureIndex, labelIndex);
      for (String line : ObjectBank.getLineIterator(new File(filename))) {
        if(lines != null)
          lines.add(line);
        dataset.add(svmLightLineToDatum(line));
      }

    } catch (Exception e) {
      throw new RuntimeException(e);
    }
    return dataset;
  }
1108291
void getXY(int cluster, Point2D pt) {
		int vindex = getClusterVertexIndex_(cluster);
		m_shape.getXYWithIndex(vindex, pt);
	}
1296643
public void dropRTreeIndex(String tableName, String geometryColumnName) {

		String sqlName = GeoPackageProperties.getProperty(SQL_PROPERTY,
				DROP_PROPERTY);
		try {
			executeSQL(sqlName, tableName, geometryColumnName);
		} catch (Exception e) {
			// If no rtree module, try to delete manually
			if (e.getMessage().indexOf("no such module: rtree") > -1) {
				sqlName = GeoPackageProperties.getProperty(SQL_PROPERTY,
						DROP_FORCE_PROPERTY);
				executeSQL(sqlName, tableName, geometryColumnName);
			} else {
				throw e;
			}
		}

	}
412964
public void setFeature(Feature feature) {
		List<Feature> features = new ArrayList<Feature>();
		features.add(feature);
		LazyLoader.lazyLoad(features, GeomajasConstant.FEATURE_INCLUDE_ATTRIBUTES, new LazyLoadCallback() {

			public void execute(List<Feature> response) {
				Feature feature = response.get(0);
				if (attributeTable == null) {
					buildWidget(feature.getLayer());
				}
				if (feature != null) {
					setTitle(I18nProvider.getAttribute().getAttributeWindowTitle(feature.getLabel()));
				} else {
					setTitle(I18nProvider.getAttribute().getAttributeWindowTitle(""));
				}
				attributeTable.setFeature(feature);
			}
		});
	}
987607
private TreeMap<Integer, Pair<String, String>> loadFeatureName(Map<String, Integer> featureIndex, BufferedReader br) throws Exception {

		TreeMap<Integer, Pair<String, String>> featureNames = new TreeMap<Integer, Pair<String, String>>();

		String temp = null;
		while (StringUtil.isNotBlank(temp = br.readLine())) {

			int indexOf = temp.indexOf(" ");

			int id = ObjConver.getIntValue(temp.substring(0, indexOf));

			if (indexOf > 0) {
				temp = temp.substring(indexOf);
			}

			String[] split = temp.split(":");

			if (split.length == 1) {
				featureNames.put(id, Pair.with(temp.trim(), ""));
			} else {
				String name = split[1];
				if (split.length > 2) {
					for (int j = 2; j < split.length; j++) {
						name += ":" + split[j];
					}
				}

				int lastFeatureId = featureIndex.get(split[0].trim());

				if ("/".equals(name)) {
					name = "//";
				}

				if (name.contains("//")) {
					name = name.replaceAll("//", "/XIEGANG/");
				}
				String featureName = toFeatureName(name.trim().split("/"), lastFeatureId);

				featureNames.put(id, Pair.with(split[0].trim(), featureName));

			}

		}

		return featureNames;

	}
540799
private void connectCTENodesIfAny(SeqScanPlanNode node) {
        if (! node.isCommonTableScan()) {
            return;
        }
        Integer CTEBaseNodeId = node.getCTEBaseNodeId();
        assert(CTEBaseNodeId != null);
        AbstractPlanNode CTEBaseNode = m_planNodesListMap.get(CTEBaseNodeId).get(0);
        assert(CTEBaseNode instanceof CommonTablePlanNode);
        node.setCTEBaseNode(CTEBaseNode);

        CommonTablePlanNode cteNode = (CommonTablePlanNode)CTEBaseNode;
        Integer CTERecursiveNodeId = cteNode.getRecursiveNodeId();
        if (CTERecursiveNodeId != null) {
            cteNode.setRecursiveNode(m_planNodesListMap.get(CTERecursiveNodeId).get(0));
        }
    }
205340
public int ensureFeature(String featureName) {
        int feature = featureToIndex.getOrDefault(featureName, -1);
        if (feature == -1) {
            synchronized (featureToIndex) {
                feature = featureToIndex.getOrDefault(featureName, -1);
                if (feature == -1) {
                    feature = featureToIndex.size();
                    featureToIndex.put(featureName, feature);
                }
            }
        }
        return feature;
    }
1009112
private void saveFeatureIndexes(FeatureIndex[] index, ZipModel model) throws IOException
	{
		logger.info(" (" + index.length + ")");

		// save the indexes
		for (int i=0;i<index.length;i++)
		{
			logger.debug("dic" + i + " size " + index[i].size());

			File tmp = File.createTempFile("dic" + i, null);
			tmp.deleteOnExit();

			BufferedWriter bwd = new BufferedWriter(new FileWriter(tmp));
			index[i].write(bwd);
			bwd.close();

			// add the dictionary to the model
			model.add(tmp, "dic" + i);
		} // end for
	}
270211
public Map<Long, FeatureShape> getFeatureIds(String database, String table) {
        Map<String, Map<Long, FeatureShape>> tables = getTables(database);
        Map<Long, FeatureShape> featureIds = getFeatureIds(tables, table);
        return featureIds;
    }
1018095
public static Dataset<String, String> readSVMLightFormat(String filename, Index<String> featureIndex, Index<String> labelIndex) {
    return readSVMLightFormat(filename, featureIndex, labelIndex, null);
  }
59862
public Extensions create(FeatureTable featureTable) {
		return create(featureTable.getTableName(), featureTable
				.getGeometryColumn().getName(), featureTable.getPkColumn()
				.getName());
	}