private static List<Double> getWeightVectorForClass(
Map<String, List<LinkedHashMap<String, Object>>> documents,
String key,
List<Integer> featureIndexList,
GraphDatabaseService db) {
List<Double> weightVector;
Transaction tx = db.beginTx();
// Get class id
Long classId =
db.findNodesByLabelAndProperty(DynamicLabel.label("Class"), "name", key)
.iterator()
.next()
.getId();
// Get weight vector for class
List<Long> longs =
documents
.get(key)
.stream()
.map(a -> ((Integer) a.get("feature")).longValue())
.collect(Collectors.toList());
weightVector =
featureIndexList
.stream()
.map(i -> longs.contains(i.longValue()) ? tfidf(db, i.longValue(), classId) : 0.0)
.collect(Collectors.toList());
tx.success();
tx.close();
return weightVector;
}
private static Double dotProduct(List<Double> v1, List<Double> v2) {
if (v1.size() != v2.size())
throw new IllegalArgumentException("Vectors must be of equal length.");
Double result = 0.0;
for (int i = 0; i < v1.size(); i++) {
result = result + (v1.get(i) * v2.get(i));
}
return result;
}
private static List<Node> getAllClasses(GraphDatabaseService db) {
Transaction tx = db.beginTx();
// Get classes using Java API
final List<Node> finalClasses = new ArrayList<>();
GlobalGraphOperations.at(db)
.getAllNodesWithLabel(DynamicLabel.label("Class"))
.forEach(a -> finalClasses.add(a));
tx.success();
tx.close();
return finalClasses.stream().map(a -> a).collect(Collectors.toList());
}
private static List<Double> getBinaryFeatureVectorForDocumentClass(
Map<String, List<LinkedHashMap<String, Object>>> documents,
List<Integer> featureIndexList,
String key) {
return featureIndexList
.stream()
.map(i -> documents.get(key).stream().anyMatch(a -> a.get("feature").equals(i)) ? 1.0 : 0.0)
.collect(Collectors.toList());
}
public List<RoadLink> getRoadLinks(Point2D pos, boolean isGrid) {
int row =
(int)
((pos.getX() - fcdSettings.getMap().getxOffset())
/ fcdSettings.getMap().getGridLength());
int col =
(int)
((pos.getY() - fcdSettings.getMap().getyOffset())
/ fcdSettings.getMap().getGridLength());
Set<String> links = new HashSet();
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
String grid = row + "+" + col;
Optional<MapGrid> mapGrid = Optional.fromNullable(gridNet.get(grid));
if (mapGrid.isPresent()) {
links.addAll(mapGrid.get().union());
}
}
}
// logger.debug("---->{}", links);
List<RoadLink> roads = new ArrayList();
for (String linkId : links) {
// logger.debug("=>{}", linkId);
Optional<RoadLink> roadLink = Optional.fromNullable(roadNet.get(Integer.valueOf(linkId)));
if (roadLink.isPresent()) {
RoadLink link = roadLink.get();
if (link.xmin < pos.getX() + 50
&& link.ymin < pos.getY() + 50
&& link.xmax > pos.getX() - 50
&& link.ymax > pos.getY() - 50) {
roads.add(link);
}
}
}
return roads;
}
private static List<Integer> getFeatureIndexList(GraphDatabaseService db) {
Transaction tx = db.beginTx();
// Get classes using Java API
final List<Node> patterns = new ArrayList<>();
GlobalGraphOperations.at(db)
.getAllNodesWithLabel(DynamicLabel.label("Pattern"))
.forEach(a -> patterns.add(a));
Collections.sort(
patterns,
(a, b) ->
((Integer) b.getProperty("threshold"))
.compareTo(((Integer) a.getProperty("threshold"))));
List<Integer> patternIds =
patterns.stream().map(a -> ((Long) a.getId()).intValue()).collect(Collectors.toList());
tx.success();
tx.close();
return patternIds;
}
private static List<Double> getFeatureVector(
GraphDatabaseService db,
GraphManager graphManager,
String input,
List<Integer> featureIndexList) {
List<LinkedHashMap<String, Object>> featureFrequencyMap =
getFeatureFrequencyMap(db, input, graphManager);
List<Integer> longs =
featureFrequencyMap
.stream()
.map(a -> (Integer) a.get("feature"))
.collect(Collectors.toList());
// ((Integer) featureFrequencyMap.stream()
// .filter(a -> (a.get("feature")).equals(i))
// .collect(Collectors.toList()).get(0).get("frequency")).doubleValue()
return featureIndexList
.stream()
.map(i -> longs.contains(i) ? 1.0 : 0.0)
.collect(Collectors.toList());
}
private Object toJsonCompatible(Object value) {
if (value instanceof Node) {
final Node node = (Node) value;
final Map<String, Object> result = SubGraph.toMap((PropertyContainer) node);
result.put("_id", node.getId());
final List<String> labelNames = SubGraph.getLabelNames(node);
if (!labelNames.isEmpty()) result.put("_labels", labelNames);
return result;
}
if (value instanceof Relationship) {
final Relationship relationship = (Relationship) value;
final Map<String, Object> result = SubGraph.toMap((PropertyContainer) relationship);
result.put("_id", relationship.getId());
result.put("_start", relationship.getStartNode().getId());
result.put("_end", relationship.getEndNode().getId());
result.put("_type", relationship.getType().name());
return result;
}
if (value instanceof Map) {
@SuppressWarnings("unchecked")
Map<String, Object> map = (Map<String, Object>) value;
final Map<String, Object> result = new LinkedHashMap<>(map.size());
for (Map.Entry<String, Object> entry : map.entrySet()) {
result.put(entry.getKey(), toJsonCompatible(entry.getValue()));
}
return result;
}
if (value instanceof Iterable) {
final List<Object> result = new ArrayList<>();
for (Object inner : (Iterable) value) {
result.add(toJsonCompatible(inner));
}
return result;
}
return value;
}
private static List<Double> getFeatureVectorForDocumentClass(
Map<String, List<LinkedHashMap<String, Object>>> documents,
List<Integer> featureIndexList,
String key) {
return featureIndexList
.stream()
.map(
i ->
documents.get(key).stream().anyMatch(a -> a.get("feature").equals(i))
? ((Integer)
documents
.get(key)
.stream()
.filter(a -> a.get("feature").equals(i))
.collect(Collectors.toList())
.get(0)
.get("frequency"))
.doubleValue()
: 0.0)
.collect(Collectors.toList());
}
public List<RoadLink> loadToDatabase(String mif, String mid, boolean saved) throws IOException {
CSVReader reader = new CSVReader(new FileReader(mid), ',', '"', 0);
String[] row;
List<RoadLink> links = new ArrayList();
while ((row = reader.readNext()) != null) {
RoadLink link = new RoadLink();
link.no = Integer.valueOf(row[0]);
link.fromNode = Integer.valueOf(row[1]);
link.toNode = Integer.valueOf(row[2]);
link.name = row[3];
link.length = Double.valueOf(row[4]);
link.ft = row[5];
link.tf = row[6];
link.combine = row[7];
link.overhead = row[8];
link.xmin = Double.valueOf(row[9]);
link.ymin = Double.valueOf(row[10]);
link.xmax = Double.valueOf(row[11]);
link.ymax = Double.valueOf(row[12]);
links.add(link);
// logger.debug("{}",link);
}
Charset charset = Charset.forName("UTF-8");
BufferedReader mifReader = Files.newBufferedReader(Paths.get(mif), charset);
String line;
int index = -1;
int pos = -1;
int segs = -1;
Point2D prePoint = null;
while ((line = mifReader.readLine()) != null) {
List<String> cols =
Lists.newArrayList(
Splitter.on(CharMatcher.BREAKING_WHITESPACE)
.trimResults()
.omitEmptyStrings()
.split(line));
// logger.debug("{}", line);
if (cols.get(0).compareTo("PLINE") == 0) {
index++;
segs = Integer.valueOf(cols.get(1));
pos = 0;
prePoint = null;
} else if (cols.get(0).compareTo("LINE") == 0) {
index++;
RoadLink link = links.get(index);
Segment seg = new Segment();
seg.start = new Point2D.Double(Double.valueOf(cols.get(1)), Double.valueOf(cols.get(2)));
seg.end = new Point2D.Double(Double.valueOf(cols.get(3)), Double.valueOf(cols.get(4)));
seg.length = seg.start.distance(seg.end);
link.segments.add(seg);
} else if (index >= 0) {
if (prePoint != null) {
prePoint = new Point2D.Double(Double.valueOf(cols.get(0)), Double.valueOf(cols.get(1)));
} else {
Segment seg = new Segment();
seg.start = prePoint;
prePoint = new Point2D.Double(Double.valueOf(cols.get(0)), Double.valueOf(cols.get(1)));
seg.end = prePoint;
seg.length = seg.start.distance(seg.end);
RoadLink link = links.get(index);
link.segments.add(seg);
}
}
}
if (saved) {
for (final RoadLink link : links) {
logger.debug("---->{}", link);
jdbcTemplate.update(
sql1,
link.no,
link.fromNode,
link.toNode,
link.name,
link.length,
link.ft,
link.tf,
link.combine,
link.overhead,
link.xmin,
link.ymin,
link.xmax,
link.ymax);
// jdbcTemplate.batchUpdate(sql2,
// new BatchPreparedStatementSetter() {
// @Override
// public int getBatchSize() {
// return link.segments.size();
// }
//
// @Override
// public void setValues(PreparedStatement ps, int i)
// throws SQLException {
// Point2D segment = link.segments.get(i);
// ps.setInt(1, link.no);
// ps.setInt(2, i);
// ps.setDouble(3, segment.getX());
// ps.setDouble(4, segment.getY());
// }
// });
}
}
// logger.debug("=>{},{}", links.size(), index);
return links;
}
public List<RoadLink> loadToDatabase(String mif, String mid) throws IOException {
logger.debug("loading {}...", mid);
CSVReader reader = new CSVReader(new FileReader(mid), ',', '"', 0);
String[] row;
List<RoadLink> links = new ArrayList();
while ((row = reader.readNext()) != null) {
RoadLink link = new RoadLink();
link.no = Integer.valueOf(row[0]);
link.fromNode = Integer.valueOf(row[1]);
link.toNode = Integer.valueOf(row[2]);
link.name = row[3];
link.length = Double.valueOf(row[4]);
link.ft = row[5];
link.tf = row[6];
link.combine = row[7];
link.overhead = row[8];
link.xmin = Double.valueOf(row[9]);
link.ymin = Double.valueOf(row[10]);
link.xmax = Double.valueOf(row[11]);
link.ymax = Double.valueOf(row[12]);
links.add(link);
roadNet.put(link.no, link);
}
for (final RoadLink link : links) {
jdbcTemplate.update(
sql1,
link.no,
link.fromNode,
link.toNode,
link.name,
link.length,
link.ft,
link.tf,
link.combine,
link.overhead,
link.xmin,
link.ymin,
link.xmax,
link.ymax);
}
Charset charset = Charset.forName("UTF-8");
BufferedReader mifReader = Files.newBufferedReader(Paths.get(mif), charset);
String line;
int index = -1;
int pos = -1;
int segs = -1;
Point2D prePoint = null;
while ((line = mifReader.readLine()) != null) {
List<String> cols =
Lists.newArrayList(
Splitter.on(CharMatcher.BREAKING_WHITESPACE)
.trimResults()
.omitEmptyStrings()
.split(line));
// logger.debug("{}", line);
if (cols.get(0).compareTo("PLINE") == 0) {
index++;
segs = Integer.valueOf(cols.get(1));
pos = 0;
prePoint = null;
} else if (cols.get(0).compareTo("LINE") == 0) {
index++;
RoadLink link = links.get(index);
// link.segments.add(new Point2D.Double(Double.valueOf(cols.get(1)),
// Double.valueOf(cols.get(2))));
// link.segments.add(new Point2D.Double(Double.valueOf(cols.get(3)),
// Double.valueOf(cols.get(4))));
Segment seg = new Segment();
seg.start = new Point2D.Double(Double.valueOf(cols.get(1)), Double.valueOf(cols.get(2)));
seg.end = new Point2D.Double(Double.valueOf(cols.get(3)), Double.valueOf(cols.get(4)));
seg.length = seg.start.distance(seg.end);
link.segments.add(seg);
} else if (index >= 0) {
if (prePoint == null) {
prePoint = new Point2D.Double(Double.valueOf(cols.get(0)), Double.valueOf(cols.get(1)));
} else {
Segment seg = new Segment();
seg.start = prePoint;
prePoint = new Point2D.Double(Double.valueOf(cols.get(0)), Double.valueOf(cols.get(1)));
seg.end = prePoint;
seg.length = seg.start.distance(seg.end);
RoadLink link = links.get(index);
link.segments.add(seg);
}
// RoadLink link = links.get(index);
// link.segments.add(new Point2D.Double(Double.valueOf(cols.get(0)),
// Double.valueOf(cols.get(1))));
}
}
return links;
}
public static Map<String, Object> getCosineSimilarityVector(GraphDatabaseService db) {
Map<String, List<LinkedHashMap<String, Object>>> documents = getFeaturesForAllClasses(db);
Map<String, List<LinkedHashMap<String, Object>>> results = new HashMap<>();
List<Integer> featureIndexList = getFeatureIndexList(db);
List<String> documentList = documents.keySet().stream().collect(Collectors.toList());
Collections.sort(documentList, (a, b) -> a.compareToIgnoreCase(b));
for (String key : documentList) {
List<LinkedHashMap<String, Object>> resultList = new ArrayList<>();
LinkedHashMap<String, Double> classMap = new LinkedHashMap<>();
List<Double> v1 =
featureIndexList
.stream()
.map(i -> documents.get(key).contains(i) ? featureIndexList.indexOf(i) : 0.0)
.collect(Collectors.toList());
documents
.keySet()
.stream()
.forEach(
otherKey -> {
List<Double> v2 =
featureIndexList
.stream()
.map(
i ->
documents.get(otherKey).contains(i)
? featureIndexList.indexOf(i)
: 0.0)
.collect(Collectors.toList());
classMap.put(otherKey, cosineSimilarity(v1, v2));
});
final List<LinkedHashMap<String, Object>> finalResultList = resultList;
classMap
.keySet()
.forEach(
ks -> {
LinkedHashMap<String, Object> localMap = new LinkedHashMap<>();
localMap.put("class", ks);
localMap.put("similarity", classMap.get(ks));
finalResultList.add(localMap);
});
Collections.sort(
finalResultList,
(a, b) -> ((String) a.get("class")).compareToIgnoreCase((String) b.get("class")));
results.put(key, finalResultList);
}
List<LinkedHashMap<String, Object>> similarityVector = new ArrayList<>();
for (String key : results.keySet()) {
List<Double> cosineVector;
cosineVector =
results
.get(key)
.stream()
.map(a -> Convert.toDouble(Math.round(100000 * (Double) a.get("similarity"))))
.collect(Collectors.toList());
LinkedHashMap<String, Object> row = new LinkedHashMap<>();
row.put("class", key);
row.put("vector", cosineVector);
similarityVector.add(row);
}
Collections.sort(
similarityVector,
(a, b) -> ((String) a.get("class")).compareToIgnoreCase((String) b.get("class")));
Map<String, Object> vectorMap = new LinkedHashMap<>();
List<ArrayList<Double>> vectors = new ArrayList<>();
List<String> classNames = new ArrayList<>();
for (LinkedHashMap<String, Object> val : similarityVector) {
vectors.add((ArrayList<Double>) val.get("vector"));
classNames.add((String) val.get("class"));
}
vectorMap.put("classes", classNames);
vectorMap.put("vectors", vectors);
return vectorMap;
}