/** * Locate the triangle with point (a Pnt) inside (or on) it. * @param point the Pnt to locate * @return triangle (Simplex<Pnt>) that holds the point; null if no such triangle */ public Simplex locate(Pnt point) { Simplex triangle = mostRecent; if (!this.contains(triangle)) triangle = null; // Try a directed walk (this works fine in 2D, but can fail in 3D) Set visited = new HashSet(); while (triangle != null) { if (visited.contains(triangle)) { // This should never happen Console.WriteLine("Warning: Caught in a locate loop"); break; } visited.add(triangle); // Corner opposite point Pnt corner = point.isOutside((Pnt[]) triangle.toArray(new Pnt[0])); if (corner == null) return triangle; triangle = this.neighborOpposite(corner, triangle); } // No luck; try brute force Console.WriteLine("Warning: Checking all triangles for " + point); for (Iterator it = this.iterator(); it.hasNext();) { Simplex tri = (Simplex) it.next(); if (point.isOutside((Pnt[]) tri.toArray(new Pnt[0])) == null) return tri; } // No such triangle Console.WriteLine("Warning: No triangle holds " + point); return null; }
/** * Place a new point site into the DT. * @param site the new Pnt * @return set of all new triangles created */ public Set delaunayPlace(Pnt site) { Set newTriangles = new HashSet(); Set oldTriangles = new HashSet(); Set doneSet = new HashSet(); LinkedList waitingQ = new LinkedList(); // Locate containing triangle if (debug) Console.WriteLine("Locate"); Simplex triangle = locate(site); // Give up if no containing triangle or if site is already in DT var triangle_null = triangle == null; if (triangle_null || triangle.contains(site)) return newTriangles; // Find Delaunay cavity (those triangles with site in their circumcircles) if (debug) Console.WriteLine("Cavity"); waitingQ.add(triangle); while (!waitingQ.isEmpty()) { triangle = (Simplex) waitingQ.removeFirst(); if (site.vsCircumcircle((Pnt[]) triangle.toArray(new Pnt[0])) == 1) continue; oldTriangles.add(triangle); Iterator it = this.neighbors(triangle).iterator(); for (; it.hasNext();) { Simplex tri = (Simplex) it.next(); if (doneSet.contains(tri)) continue; doneSet.add(tri); waitingQ.add(tri); } } // Create the new triangles if (debug) Console.WriteLine("Create"); for (Iterator it = Simplex.boundary(oldTriangles).iterator(); it.hasNext();) { Set facet = (Set) it.next(); facet.add(site); newTriangles.add(new Simplex(facet)); } // Replace old triangles with new triangles if (debug) Console.WriteLine("Update"); this.update(oldTriangles, newTriangles); // Update mostRecent triangle if (!newTriangles.isEmpty()) mostRecent = (Simplex) newTriangles.iterator().next(); return newTriangles; }
/** * Report the boundary of a Set of Simplices. * The boundary is a Set of facets where each facet is a Set of vertices. * @return an Iterator for the facets that make up the boundary */ public static Set boundary(Set simplexSet) { Set theBoundary = new HashSet(); for (Iterator it = simplexSet.iterator(); it.hasNext(); ) { Simplex simplex = (Simplex)it.next(); for (Iterator otherIt = simplex.facets().iterator(); otherIt.hasNext(); ) { Set facet = (Set)otherIt.next(); if (theBoundary.contains(facet)) theBoundary.remove(facet); else theBoundary.add(facet); } } return theBoundary; }
private SourceCompilerResults compileCore(IProgressMonitor monitor) { var t0 = System.nanoTime(); var results = new SourceCompilerResults(); var hasErrors = false; var errorManager = new CodeErrorManager(); var allFiles = parameters.AllFiles; Iterable<IFile> filesToCompile = null; try { monitor.beginTask("", 11); var deletedFiles = parameters.FilesToCompile .select(p => allFiles.getResource(p)) .where(p => p == null || !p.exists()) .select(p => allFiles.getProjectRelativeName(p)).toSet(); var typesToCopy = Query.empty<TypeInfo>(); // Get the files to compile if (parameters.FullBuild) { filesToCompile = allFiles.getAllResources().where(p => p.exists()).toList(); } else { bool filteringDone = false; var referencingFiles = parameters.getDependencyInfo().getAllReferencingFiles(parameters.getFilesToCompile()); if (parameters.ProgressiveBuild && deletedFiles.isEmpty()) { var referencedFiles = parameters.getDependencyInfo().getAllReferencedFiles(parameters.getFilesToCompile()); referencedFiles = referencedFiles.except(parameters.getFilesToCompile()); referencedFiles = referencedFiles.intersect(referencingFiles); // Progressive build only if referenced and referencing files do not intersect if (!referencedFiles.any()) { filesToCompile = parameters.FilesToCompile.select(p => allFiles.getResource(p)).where(p => p.exists()).toList(); filteringDone = true; } } if (!filteringDone) { // Incremental build with dependencies filesToCompile = referencingFiles.select(p => allFiles.getResource(p)).where(p => p.exists()).toList(); } var filesToKeep = allFiles.getAllProjectRelativeNames().except(referencingFiles); typesToCopy = filesToKeep.selectMany(p => parameters.DependencyInfo.getFileContents(p)) .where(p => p.indexOf('$') == -1).select(p => parameters.TypeSystem.getType(p)); Environment.trace(this, "keeping " + filesToKeep.count() + " files"); Environment.trace(this, "ignoring " + (allFiles.getAllResources().count() - filesToCompile.count() - filesToKeep.count()) + " files"); } Environment.trace(this, "compiling " + filesToCompile.count() + " files"); monitor.worked(1); if (monitor.isCanceled()) { throw new InterruptedException(); } var compilationUnits = new HashMap<String, CompilationUnitNode>(); // Parsing foreach (var file in filesToCompile) { var text = getText(file); if (text != null) { parse(file, text, errorManager, compilationUnits); } } monitor.worked(1); if (monitor.isCanceled()) { throw new InterruptedException(); } // Compiling var t1 = System.nanoTime(); var typeSystem = new Library(parameters.ClassPath); JvmTypeSystemHelper.cloneTypes(typesToCopy, typeSystem); var annotatedTypeSystem = new Library(new[] { Environment.getLibraryPath("stabal.jar") }, typeSystem); var cparams = new CompilerParameters(); cparams.TypeSystem = typeSystem; cparams.AnnotatedTypeSystem = annotatedTypeSystem; cparams.GenerateClassFiles = parameters.GenerateClassFiles; cparams.ProgressTracker = new CompilationProgressTracker(monitor); var cunits = compilationUnits.values().toArray(new CompilationUnitNode[compilationUnits.size()]); var cresults = new StabCompiler().compileFromCompilationUnits(cparams, cunits); Environment.trace(this, "compilation of " + sizeof(cunits) + " files done in " + ((System.nanoTime() - t1) / 1e6) + "ms"); foreach (var error in cresults.Errors) { if (error.Level == 0) { hasErrors = true; } results.CodeErrors.add(error); Environment.trace(this, "error (" + error.Line + ", " + error.Column + ") " + error.Filename + ": " + error.Message); } if (!hasErrors) { var dependencyInfo = new DependencyInfo(); results.DependencyInfo = dependencyInfo; var allTypes = new HashSet<String>(); // Copy informations from unbuilt files if (parameters.DependencyInfo != null) { var unbuiltFiles = allFiles.getAllProjectRelativeNames(); unbuiltFiles = unbuiltFiles.except(filesToCompile.select(p => allFiles.getProjectRelativeName(p))); unbuiltFiles = unbuiltFiles.except(deletedFiles); foreach (var file in unbuiltFiles) { foreach (var type in parameters.DependencyInfo.getFileContents(file)) { allTypes.add(type); dependencyInfo.addFileToTypeRelation(file, type); foreach (var refType in parameters.DependencyInfo.getReferencedTypes(type)) { dependencyInfo.addTypeToTypeRelation(type, refType); } } } } // Collect the types and update the dependencies. var typeMembers = new HashMap<IFile, Iterable<TypeMemberNode>>(); foreach (var file in filesToCompile) { var fileName = allFiles.getProjectRelativeName(file); var compilationUnit = compilationUnits[fileName]; if (compilationUnit == null) { continue; } var members = SyntaxTreeHelper.getTypeMembers(compilationUnit); typeMembers.put(file, members); foreach (var member in members) { var typeName = member.getUserData(typeof(TypeInfo)).FullName; dependencyInfo.addFileToTypeRelation(fileName, typeName); allTypes.add(typeName); } } if (parameters.DependencyInfo != null) { // Copy the types ignored by this compilation var missingTypes = new HashSet<TypeInfo>(); foreach (var t in allTypes.where(p => p.indexOf('$') == -1 && !typeSystem.typeExists(p))) { if (hasErrors = !parameters.DependencyInfo.getReferencedTypes(t).all(p => allTypes.contains(p))) { Environment.trace(this, "Incremental build failed: a type was deleted"); break; } missingTypes.add(parameters.TypeSystem.getType(t)); } if (!hasErrors) { JvmTypeSystemHelper.cloneTypes(missingTypes, typeSystem); } } if (!hasErrors) { // Compute the dependencies in the compiled files foreach (var member in filesToCompile.select(p => typeMembers[p]).where(p => p != null).selectMany(p => p)) { foreach (var t in SyntaxTreeHelper.getTypeMemberDependencies(member) .intersect(allTypes.select(p => JvmTypeSystemHelper.getType(typeSystem, p)))) { dependencyInfo.addTypeToTypeRelation(member.getUserData(typeof(TypeInfo)).FullName, t.FullName); } } results.TypeSystem = typeSystem; results.AnnotatedTypeSystem = annotatedTypeSystem; foreach (var e in compilationUnits.entrySet()) { results.CompilationUnits[e.Key] = e.Value; } foreach (var e in cresults.ClassFiles.entrySet()) { results.ClassFiles[e.Key] = e.Value; } } } monitor.worked(1); } catch (CodeErrorException e) { monitor.worked(10); } catch (TypeLoadException e) { results.MissingType = e.TypeName; hasErrors = true; monitor.worked(6); } finally { monitor.done(); } foreach (var file in filesToCompile) { results.CompiledFiles.add(allFiles.getProjectRelativeName(file)); } foreach (var error in errorManager.Errors) { if (error.Level == 0) { hasErrors = true; } results.CodeErrors.add(error); Environment.trace(this, "error (" + error.Line + ", " + error.Column + ") " + error.Filename + ": " + error.Message); } results.Failed = hasErrors; Environment.trace(this, "compilation done in " + ((System.nanoTime() - t0) / 1e6) + "ms"); return results; }
private bool hasUnfixedTypeVariablesDependingOn(TypeInfo type, HashMap<TypeInfo, TypeVariableInfo> typeVariableInfos, HashSet<TypeInfo> visited) { if (visited.contains(type)) { return false; } visited.add(type); foreach (var tv in typeVariableInfos.values()) { if (tv.fixedType == null) { if (tv.dependencies.contains(type)) { return true; } } else if (tv.dependencies.contains(type)) { foreach (var t in tv.dependencies) { if (hasUnfixedTypeVariablesDependingOn(t, typeVariableInfos, visited)) { return true; } } } } return false; }