private Action<?> walk(AmObject cobj) { Action<?> action = visitor.preorderVisit(cobj, context); if (action == null) action = Action.next(); final AmObject walkObj = extractWalkObject(cobj, action); if (walkObj != null) { // walk children UpdatingIterator it = getChildrenOf(walkObj); context.getAmParents().addLast(walkObj); while (it.hasNext()) { AmObject child = it.next(); Action<?> childAction = walk(child); processAction(childAction, it); } context.getAmParents().removeLast(); } Action<?> postAction = visitor.postorderVisit(walkObj != null ? walkObj : cobj, context, action); if (postAction == null) postAction = Action.next; action = action.mergeWith(postAction); return action; }
/** * Adds the value to the collection given by map.get(key). A new collection is created using the * supplied CollectionFactory. */ public static <K, V, C extends Collection<V>> void putIntoValueCollection( Map<K, C> map, K key, V value, CollectionFactory<V> cf) { C c = map.get(key); if (c == null) { c = ErasureUtils.<C>uncheckedCast(cf.newCollection()); map.put(key, c); } c.add(value); }
/** * Gets an object from the cache. Performs a cleanup first If accessOrder is true, refreshed the * timestamp * * @param key the key of the object * @return the object or null */ @Override public C get(Object key) { cleanup(); C value = super.get(key); if (accessOrder && value != null) { value.refreshCacheTime(); } return value; }
public static void testConfigurableForNonPrimitives() { Map<String, String> p = new HashMap<String, String>(); C config = Configurable.createConfigurable(C.class, p); assertNull(config.port()); p.put("port", "10"); config = Configurable.createConfigurable(C.class, p); assertEquals(Integer.valueOf(10), config.port()); // property port is // not set }
@SuppressWarnings("unchecked") private void executeAndRestoreDefaultProjectSettings( @NotNull Project project, @NotNull Runnable task) { if (!project.isDefault()) { task.run(); return; } AbstractExternalSystemSettings systemSettings = ExternalSystemApiUtil.getSettings(project, myExternalSystemId); Object systemStateToRestore = null; if (systemSettings instanceof PersistentStateComponent) { systemStateToRestore = ((PersistentStateComponent) systemSettings).getState(); } systemSettings.copyFrom(myControl.getSystemSettings()); Collection projectSettingsToRestore = systemSettings.getLinkedProjectsSettings(); systemSettings.setLinkedProjectsSettings( Collections.singleton(getCurrentExternalProjectSettings())); try { task.run(); } finally { if (systemStateToRestore != null) { ((PersistentStateComponent) systemSettings).loadState(systemStateToRestore); } else { systemSettings.setLinkedProjectsSettings(projectSettingsToRestore); } } }
public static <R, I, C extends Collection<R>> C collect( Iterable<? extends I> source, C destination, Transformer<R, I> transformer) { for (I item : source) { destination.add(transformer.transform(item)); } return destination; }
@NotNull private static <T, C extends Collection<T>> C copy( @NotNull C collection, @NotNull Iterable<? extends T> elements) { for (T element : elements) { collection.add(element); } return collection; }
public static <T, C extends Collection<T>> C filter( Iterable<? extends T> source, C destination, Spec<? super T> filter) { for (T item : source) { if (filter.isSatisfiedBy(item)) { destination.add(item); } } return destination; }
@NotNull private ExternalProjectSettings getCurrentExternalProjectSettings() { ExternalProjectSettings result = myControl.getProjectSettings().clone(); File externalProjectConfigFile = getExternalProjectConfigToUse(new File(result.getExternalProjectPath())); final String linkedProjectPath = FileUtil.toCanonicalPath(externalProjectConfigFile.getPath()); assert linkedProjectPath != null; result.setExternalProjectPath(linkedProjectPath); return result; }
/** * Checks if the cache has been cleaned recently. If not, starts with the oldest elements, and * checks which are to old. If one is found to be not to old, all the others are assumed to be * not to old, and the cleanup is over. */ private void cleanup() { if (!isTooOld(lastClean, timeBetweenGC)) { return; } lastClean = System.currentTimeMillis(); // With very low timeout this check could lead to infinite recursion /* if (super.isEmpty()) { return; } */ Iterator<C> iterator = values().iterator(); while (iterator.hasNext()) { C element = iterator.next(); if (isTooOld(element.getCacheTime(), timeToLive)) { iterator.remove(); } else { break; } } }
public void runAlgorithm() { // traceHull = null; COper3.dbClear(); traceHullPt = null; traceValley = null; simple = null; focusPt = null; possHull = null; valleyTri = null; PtEntry.resetIds(); EdPolygon[] rgn = UHullMain.getPolygons(); if (rgn.length < 2) return; if (C.vb(OLDALG)) { T.disable(); simple = PossHullOper.buildPossibleHull(rgn); T.enable(); } possHull = calcPHullRange(rgn, 0, rgn.length - 1); }
@Override protected void syncVars(Sync sync) { preloadIn = (Graph) C.sync("preloadIn", preloadIn, sync); }
private static void insertValleys( PtEntry hullPt, Object aSrc, Object bSrc) { // pa, MyPolygon pb) { boolean db = C.vb(DB_INSERTVALLEY); PtEntry ent = hullPt; if (db && T.update()) T.msg("insertValleys"); do { PtEntry next = ent.next(true); if (ent.source() == next.source()) { PtEntry orig = ent.orig(); if (orig.next(true) != next.orig()) { PtEntry vPeak0 = ent; PtEntry vPeak1 = next; EdPolygon opp = (EdPolygon) (vPeak0.source() == aSrc ? bSrc : aSrc); FPoint2 kernelPt = opp.getPointMod(C.vi(KERNELVERT)); // construct a chain from the vertices of the valley PtEntry handle = new PtEntry(vPeak0); PtEntry hNext = handle; PtEntry e = vPeak0.orig(); while (e != vPeak1.orig()) { inf.update(); e = e.next(true); hNext = hNext.insert(new PtEntry(e), true); } if (C.vb(SKIPCONTOUR)) { PtEntry h0 = handle.next(true); PtEntry h1 = hNext.prev(true); PtEntry.join(vPeak0, h0); PtEntry.join(h1, vPeak1); if (db && T.update()) T.msg("inserted unmodified valley" + T.show(vPeak0) + T.show(vPeak1)); } else { if (!C.vb(DB_CONTOUR)) T.disable(); PtEntry hull = COper3.buildHullForChain(handle, kernelPt); if (!C.vb(DB_CONTOUR)) T.enable(); // find entries corresponding to start, end of hull PtEntry peak0 = null, peak1 = null; { PtEntry hEnt = hull; while (peak0 == null || peak1 == null) { inf.update(); if (hEnt.orig() == vPeak0.orig()) peak0 = hEnt; if (hEnt.orig() == vPeak1.orig()) peak1 = hEnt; hEnt = hEnt.next(true); } } PtEntry.join(vPeak0, peak0.next(true)); PtEntry.join(peak1.prev(true), vPeak1); if (db && T.update()) T.msg("inserted monotonic valley" + T.show(vPeak0) + T.show(vPeak1)); } } } ent = next; } while (ent != hullPt); }
public void addControls() { C.sOpenTab("Valley"); { C.sStaticText( // "Generate possible hull in O(n log k) time, using 'valley' algorithm"); C.sCheckBox( DB_INITIALHULL, "db initial hull", "trace construction of initial convex hull of the two polygons", false); C.sCheckBox(DB_CONTOUR, "db pt/poly", "trace point / polygon hull construction", false); C.sCheckBox( DB_INSERTVALLEY, "db insert valley", "trace insertion of monotonic valley edges", false); C.sCheckBox(DB_HULLEXPAND, "db expand", "trace hull expansion procedure", false); C.sCheckBox( SKIPCONTOUR, "skip contour", "use original polygons and not their contours\n" + "(required to ensure monotonicity of tangent searches)", false); C.sCheckBox(OLDALG, "simple", "plot possible hull using old algorithm", false); C.sCheckBox(OLDMETHOD, "old", "use old code", false); C.sIntSpinner( KERNELVERT, "kernel vertex", "specifies which vertex of the other polygon to use as point in pt/poly step", 0, 50, 0, 1); } C.sCloseTab(); }
public Tester(C container, List<Test<C>> tests) { this.container = container; this.tests = tests; if (container != null) headline = container.getClass().getSimpleName(); }
/** * Apply hull expansion procedure * * @param convHullEntry an entry of the hull (should be on the convex hull, so it is not deleted * or replaced and is still valid for subsequent calls) * @param aHull entry on convex hull of polygon A * @param bHull entry on convex hull of polygon B * @param ccw true to move in ccw direction, else cw */ private static void expandHull(PtEntry convHullEntry, PtEntry aHull, PtEntry bHull, boolean ccw) { if (C.vb(OLDMETHOD)) { OLDexpandHull(convHullEntry, aHull, bHull, ccw); return; } boolean db = C.vb(DB_HULLEXPAND); if (db && T.update()) T.msg("expandHull" + T.show(convHullEntry) + " ccw=" + ccw); // tangent points for A, B PtEntry[] tangentPoints = new PtEntry[2]; tangentPoints[0] = aHull; tangentPoints[1] = bHull; PtEntry hEnt = convHullEntry; do { inf.update(); // calculate tangent ray R PtEntry tangentPt = null; while (true) { int tanIndex = (hEnt.source() == tangentPoints[0].source()) ? 1 : 0; tangentPt = tangentPoints[tanIndex]; if (!COper3.right(hEnt, tangentPt, tangentPt.next(true), ccw) && !COper3.right(hEnt, tangentPt, tangentPt.prev(true), ccw)) break; tangentPt = tangentPt.next(ccw); if (db && T.update()) T.msg( "expandHull, advance tangent line" + T.show(tangentPt.toPolygon(), MyColor.cDARKGRAY, -1, MARK_DISC) + T.show(hEnt) + tl(hEnt, tangentPt)); tangentPoints[tanIndex] = tangentPt; } if (COper3.left(hEnt, tangentPt, hEnt.next(ccw), ccw)) { DArray dispPts = new DArray(); // delete points until cross tangent line PtEntry next = hEnt.next(ccw); while (true) { PtEntry prev = next; dispPts.add(prev); next = prev.delete(ccw); if (COper3.right(hEnt, tangentPt, next, ccw)) { FPoint2 cross = MyMath.linesIntersection(hEnt, tangentPt, prev, next, null); hEnt = hEnt.insert(new PtEntry(cross), ccw); if (db && T.update()) T.msg( "expandHull, clipped to shadow region" + tl(hEnt, tangentPt) + T.show(hEnt) + T.show(dispPts)); break; } } } else { if (db && T.update()) T.msg( "expandHull, not dipping into shadow region" + T.show(hEnt.next(ccw)) + tl(hEnt, tangentPt)); } while (true) { hEnt = hEnt.next(ccw); if (COper3.left(hEnt.prev(ccw), hEnt, hEnt.next(ccw), ccw)) break; if (db && T.update()) T.msg("skipping reflex vertex" + T.show(hEnt)); } } while (hEnt != convHullEntry); }
@Nullable private File getProjectFile() { String path = myControl.getProjectSettings().getExternalProjectPath(); return path == null ? null : new File(path); }
/** * Determine convex hull of two polygons, using rotating calipers method * * @param pa first polygon * @param pb second polygon * @return convex hull structure */ private static PtEntry hullOfPolygons(PtEntry pa, PtEntry pb, PtEntry aHull, PtEntry bHull) { boolean db = C.vb(DB_INITIALHULL); if (db && T.update()) T.msg( "construct convex hull of polygons" + T.show(pa, MyColor.cBLUE, STRK_THICK, -1) + T.show(pb, MyColor.cDARKGREEN, STRK_THICK, -1)); PtEntry hullVertex = null; // A hull vertex and index PtEntry av = rightMostVertex(aHull); // B hull vertex and index PtEntry bv = rightMostVertex(bHull); double theta = Math.PI / 2; LineEqn aLine = new LineEqn(av, theta); int bSide = aLine.sideOfLine(bv); boolean bActive = (bSide == 0) ? (bv.y > av.y) : bSide < 0; if (db && T.update()) T.msg("rightmost vertices" + T.show(av) + T.show(bv)); // construct initial vertex of hull hullVertex = new PtEntry(!bActive ? av : bv); // if (db && T.update()) // T.msg("constructed initial hull vertex: " + hullVertex); PtEntry.join(hullVertex, hullVertex); PtEntry firstEnt = hullVertex; while (true) { Inf.update(inf); PtEntry av2 = av.next(true); PtEntry bv2 = bv.next(true); // next vertex is either A advance, B advance, or bridge double anga = MyMath.polarAngle(av, av2); double angb = MyMath.polarAngle(bv, bv2); double angBridge = bActive ? MyMath.polarAngle(bv, av) : MyMath.polarAngle(av, bv); double ta = MyMath.normalizeAnglePositive(anga - theta); double tb = MyMath.normalizeAnglePositive(angb - theta); double tc = MyMath.normalizeAnglePositive(angBridge - theta); // precision problem: if A and B tangent lines are parallel, both can // reach near zero simultaneously final double MAX = Math.PI * 2 - 1e-3; if (ta >= MAX) ta = 0; if (tb >= MAX) tb = 0; if (tc >= MAX) tc = 0; theta += Math.min(ta, Math.min(tb, tc)); if (db && T.update()) T.msg("caliper" + T.show(hullVertex) + tr(hullVertex, theta) + tp(av) + tp(bv)); PtEntry newPoint = null; if (ta <= tb && ta <= tc) { if (db && T.update()) T.msg("A vertex is nearest" + tl(av, av2)); // ai++; av = av2; if (!bActive) newPoint = av; } else if (tb <= ta && tb <= tc) { if (db && T.update()) T.msg("B vertex is nearest" + tl(bv, bv2)); // bi++; bv = bv2; if (bActive) newPoint = bv; } else { if (db && T.update()) T.msg("Bridge vertex is nearest" + tl(bActive ? bv : av, bActive ? av : bv)); bActive ^= true; newPoint = bActive ? bv : av; } if (newPoint != null) { if (PtEntry.samePoint(newPoint, firstEnt)) { break; } // construct new vertex for hull of the two; // remember, use original vertex, not the convex hull hullVertex = hullVertex.insert(new PtEntry(newPoint), true); if (db && T.update()) T.msg("adding new caliper vertex " + T.show(hullVertex)); } } return hullVertex; }
@Override protected void syncVars(Sync sync) { filter = (Boolean) C.sync("filter", filter, sync); continuation = (Finder) C.sync("continuation", continuation, sync); pattern = (TriplePattern) C.sync("pattern", pattern, sync); }
public void prepare(@NotNull WizardContext context) { myControl.reset(); String pathToUse = context.getProjectFileDirectory(); myControl.setLinkedProjectPath(pathToUse); doPrepare(context); }
@Override protected void syncVars(Sync sync) { t = (Triple) C.sync("t", t, sync); }
private static void OLDexpandHull( PtEntry convHullEntry, PtEntry aHull, PtEntry bHull, boolean ccw) { boolean db__OLD = C.vb(DB_HULLEXPAND); if (db__OLD && T.update()) T.msg("expandHull" + T.show(convHullEntry) + " ccw=" + ccw); PtEntry[] opp = new PtEntry[2]; opp[0] = aHull; opp[1] = bHull; PtEntry old____hEnt = convHullEntry; boolean advanced = false; do { if (old____hEnt != convHullEntry) advanced = true; inf.update(); if (old____hEnt.source() == null) { if (db__OLD && T.update()) T.msg("expandHull, source unknown, guaranteed not convex" + T.show(old____hEnt)); old____hEnt = old____hEnt.next(ccw); continue; } int w = (old____hEnt.source() == opp[0].source()) ? 1 : 0; PtEntry oppEnt = opp[w]; boolean isTangent = !COper3.right(old____hEnt, oppEnt, oppEnt.next(true), ccw) && !COper3.right(old____hEnt, oppEnt, oppEnt.prev(true), ccw); if (!isTangent) { if (db__OLD && T.update()) T.msg( "expandHull, advance tangent line" + T.show(oppEnt.toPolygon(), MyColor.cDARKGRAY, -1, MARK_X) + T.show(old____hEnt) + tl(old____hEnt, oppEnt)); opp[w] = oppEnt.next(ccw); continue; } if (COper3.left(old____hEnt, oppEnt, old____hEnt.next(ccw), ccw) && COper3.left(old____hEnt, oppEnt, old____hEnt.prev(ccw), ccw)) { DArray dispPts = new DArray(); // delete points until cross tangent line PtEntry next = old____hEnt.next(ccw); while (true) { PtEntry prev = next; dispPts.add(prev); next = prev.delete(ccw); inf.update(); if (COper3.right(old____hEnt, oppEnt, next, ccw)) { FPoint2 cross = MyMath.linesIntersection(old____hEnt, oppEnt, prev, next, null); old____hEnt = old____hEnt.insert(new PtEntry(cross), ccw); if (db__OLD && T.update()) T.msg( "expandHull, clipped to shadow region" + tl(old____hEnt, oppEnt) + T.show(old____hEnt) + T.show(dispPts)); break; } } } else { if (db__OLD && T.update()) T.msg( "expandHull, not dipping into shadow region" + T.show(old____hEnt.next(ccw)) + tl(old____hEnt, oppEnt)); } old____hEnt = old____hEnt.next(ccw); } while (!advanced || old____hEnt != convHullEntry); }
public static void main(String[] args) throws Exception { C solver = new C(); solver.solve(); solver.end(); }
@NotNull public C getControl(@Nullable Project currentProject) { myControl.setCurrentProject(currentProject); return myControl; }