use of cbit.vcell.geometry.surface.Node in project vcell by virtualcell.
the class RasterExporter method writeStanfordPolygonTex.
public static PolyTexHelper writeStanfordPolygonTex(RegionImage regionImage, Writer writer, /*BitSet bInDomain,*/
CartesianMesh mesh) throws IOException, MathException {
int totalPolygons = regionImage.getSurfacecollection().getTotalPolygonCount();
int totalVerts = totalPolygons * 4;
final int ALL_NEIGHBOR_QUAD_BOX_SIDE = 3;
// 2D image texture
int imgSideSize = (int) Math.ceil(Math.sqrt((totalPolygons)));
int texelXSize = (imgSideSize * ALL_NEIGHBOR_QUAD_BOX_SIDE);
int[][] texIndexToFaceIndexPtrs = new int[texelXSize * texelXSize][0];
// Arrays.fill(texImage0, Integer.MAX_VALUE);
final int squareSize = 40;
int fontXSize = texelXSize * squareSize;
int fontYSize = texelXSize * squareSize;
BufferedImage image0 = createTextureImage(fontXSize);
// int[] texFontImage = new int[fontXSize*fontYSize];
// Arrays.fill(texFontImage, 0xFF000000);
// int[] bitMasks0 = new int[]{0xFF0000, 0xFF00, 0xFF, 0xFF000000};
// SinglePixelPackedSampleModel sm0 = new SinglePixelPackedSampleModel(
// DataBuffer.TYPE_INT, texelXSize*squareSize, texelXSize*squareSize, bitMasks0);
// DataBufferInt db0 = new DataBufferInt(texFontImage, texFontImage.length);
// WritableRaster wr0 = Raster.createWritableRaster(sm0, db0, new Point());
// BufferedImage image0 = new BufferedImage(ColorModel.getRGBdefault(), wr0, false, null);
Graphics2D g2d = image0.createGraphics();
g2d.setColor(Color.white);
Font bigF = Font.decode("Dialog-plain-10");
g2d.setFont(bigF);
float texelSize = 1.0f / texelXSize;
writer.write("ply\n");
writer.write("format ascii 1.0\n");
// writer.write("comment "+geometrySurfaceDescription.getGeometry().getName()+"\n");
writer.write("comment textureImage size is " + imgSideSize + "x" + imgSideSize + "\n");
writer.write("element vertex " + totalVerts + "\n");
writer.write("property float x\n");
writer.write("property float y\n");
writer.write("property float z\n");
// must be 's' for blender (u texture coord)
writer.write("property float s\n");
// must be 't' for blender (v texture coord)
writer.write("property float t\n");
writer.write("element face " + totalPolygons + "\n");
writer.write("property list uchar int vertex_index\n");
writer.write("end_header\n");
StringBuffer sbVert = new StringBuffer();
StringBuffer sbFace = new StringBuffer();
int faceIndex = 0;
int vertIndex = 0;
for (int currSurf = 0; currSurf < regionImage.getSurfacecollection().getSurfaceCount(); currSurf++) {
for (int currFace = 0; currFace < regionImage.getSurfacecollection().getSurfaces(currSurf).getPolygonCount(); currFace++) {
// if(bInDomain != null && !bInDomain.get(faceIndex)){
// continue;
// }
g2d.setColor(Color.white);
Quadrilateral quad = (Quadrilateral) regionImage.getSurfacecollection().getSurfaces(currSurf).getPolygons(currFace);
NAHelper naHelper0 = calcNAHelper(quad);
Point2D p2dm = Coordinate.get2DProjection(naHelper0.middle, naHelper0.normalAxis);
int x = faceIndex % imgSideSize;
int y = faceIndex / imgSideSize;
int boxX = (x * ALL_NEIGHBOR_QUAD_BOX_SIDE) + 1;
int boxY = (y * ALL_NEIGHBOR_QUAD_BOX_SIDE) + 1;
int fontX = boxX * squareSize;
int fontY = boxY * squareSize;
// das.getColorFromValue(data[faceIndex]);//face color
texIndexToFaceIndexPtrs[boxY * texelXSize + boxX] = new int[] { faceIndex };
g2d.drawString(currSurf + "-" + currFace, fontX, fontY);
float imgXTexelCenter = (boxX + .5f) * texelSize;
float imgYTexelCenter = (boxY + .5f) * texelSize;
ArrayList<RegionImage.MembraneEdgeNeighbor> neighbors = regionImage.getMembraneEdgeNeighbors()[currSurf][currFace];
sbFace.append(quad.getNodeCount() + "");
for (int vrt = 0; vrt < quad.getNodeCount(); vrt++) {
g2d.setColor(Color.white);
RegionImage.MembraneEdgeNeighbor membraneEdgeNeighbor = neighbors.get(vrt);
MembraneElementIdentifier neighb = membraneEdgeNeighbor.getMembraneElementIdentifier();
if (neighb != null) {
Quadrilateral quadNeighbor = (Quadrilateral) regionImage.getSurfacecollection().getSurfaces(neighb.surfaceIndex).getPolygons(neighb.nonMasterPolygonIndex);
NAHelper naHelper1 = calcNAHelper(quadNeighbor);
Point2D p2dmNeighb = Coordinate.get2DProjection(naHelper1.middle, naHelper0.normalAxis);
double xdiff = p2dmNeighb.getX() - p2dm.getX();
double ydiff = p2dmNeighb.getY() - p2dm.getY();
int dxn = (int) Math.signum((Math.abs(xdiff) < 1e-9 ? 0 : xdiff));
int dyn = (int) Math.signum((Math.abs(ydiff) < 1e-9 ? 0 : ydiff));
// das.getColorFromValue(data[membraneEdgeNeighbor.getMasterPolygonIndex()]);
texIndexToFaceIndexPtrs[(boxY + dyn) * texelXSize + (boxX + dxn)] = new int[] { membraneEdgeNeighbor.getMasterPolygonIndex() };
g2d.drawString(neighb.nonMasterPolygonIndex + "", fontX + (dxn * squareSize), fontY + (dyn * squareSize));
RegionImage.MembraneEdgeNeighbor membraneEdgeNeighbor2 = neighbors.get((vrt + 1 == quad.getNodeCount() ? 0 : vrt + 1));
MembraneElementIdentifier neighb2 = membraneEdgeNeighbor2.getMembraneElementIdentifier();
if (neighb2 != null) {
CommonNeighb commonNeighb = calculateCommonNeighbor(mesh, regionImage, mesh.getMembraneElements()[membraneEdgeNeighbor.getMasterPolygonIndex()], mesh.getMembraneElements()[membraneEdgeNeighbor2.getMasterPolygonIndex()], faceIndex);
if (commonNeighb != null) {
if (commonNeighb.neighborneighbos.size() == 0) {
commonNeighb.neighborneighbos.add(membraneEdgeNeighbor.getMasterPolygonIndex());
commonNeighb.neighborneighbos.add(membraneEdgeNeighbor2.getMasterPolygonIndex());
}
// mesh.getMembraneElements()[commonNeighb].getCentroid();
Coordinate commonCoord = new Coordinate(commonNeighb.node.getX(), commonNeighb.node.getY(), commonNeighb.node.getZ());
Point2D p2dmcommon = Coordinate.get2DProjection(commonCoord, naHelper0.normalAxis);
double xdiff1 = p2dmcommon.getX() - p2dm.getX();
double ydiff1 = p2dmcommon.getY() - p2dm.getY();
int dxc = (int) Math.signum((Math.abs(xdiff1) < 1e-9 ? 0 : xdiff1));
int dyc = (int) Math.signum((Math.abs(ydiff1) < 1e-9 ? 0 : ydiff1));
g2d.setColor(Color.green);
int xloc = fontX + (dxc * squareSize);
int yloc = fontY + (dyc * squareSize);
double avgVal = 0;
int texIndex = (boxY + dyc) * texelXSize + boxX + dxc;
texIndexToFaceIndexPtrs[texIndex] = new int[commonNeighb.neighborneighbos.size()];
for (int k = 0; k < commonNeighb.neighborneighbos.size(); k++) {
g2d.drawString(regionImage.getQuadIndexToSurfAndFace().get(commonNeighb.neighborneighbos.get(k)).getFace() + "", xloc, yloc + (k * 11));
// avgVal+= data[commonNeighb.neighborneighbos.get(k)];
// das.getColorFromValue(avgVal/commonNeighb.neighborneighbos.size());
texIndexToFaceIndexPtrs[texIndex][k] = commonNeighb.neighborneighbos.get(k);
}
// if(texImage0[texIndex] != Integer.MAX_VALUE){
// System.out.println("texture pixel used twice");
// }
}
}
} else {
System.out.println("neighbor null");
}
Point2D p2dv = Coordinate.get2DProjection(new Coordinate(quad.getNodes(vrt).getX(), quad.getNodes(vrt).getY(), quad.getNodes(vrt).getZ()), naHelper0.normalAxis);
double xdiff3 = p2dv.getX() - p2dm.getX();
double ydiff3 = p2dv.getY() - p2dm.getY();
int dx = (int) Math.signum((Math.abs(xdiff3) < 1e-9 ? 0 : xdiff3));
int dy = (int) Math.signum((Math.abs(ydiff3) < 1e-9 ? 0 : ydiff3));
float u = (float) imgXTexelCenter + ((float) dx * texelSize / 2.0f);
float v = (float) imgYTexelCenter + ((float) dy * texelSize / 2.0f);
Node vertex = quad.getNodes()[vrt];
sbVert.append((float) vertex.getX() + " " + (float) vertex.getY() + " " + (float) vertex.getZ() + " " + u + " " + v + "\n");
sbFace.append(" ");
sbFace.append(vertIndex + "");
vertIndex++;
}
sbFace.append("\n");
faceIndex++;
}
}
if (faceIndex != totalPolygons || vertIndex != totalVerts) {
throw new IOException("Final faces and verts count don't match");
}
writer.write(sbVert.toString());
writer.write(sbFace.toString());
// ImageIO.write(op0.filter(image0, null), "png", baos);
return new PolyTexHelper(texIndexToFaceIndexPtrs, flipPNG(image0), texelXSize);
}
use of cbit.vcell.geometry.surface.Node in project vcell by virtualcell.
the class ROIMultiPaintManager method calcMinMax.
private static StatsHelper calcMinMax(File[] selectedFiles) throws Exception {
ArrayList<SurfaceCollection> allSurfCollections = new ArrayList<>();
TreeMap<String, TreeMap<Integer, ArrayList<TreeMap<Integer, TreeSet<Integer>>>>> fileMapSurfMapSubsurf = new TreeMap<>();
for (int j = 0; j < selectedFiles.length; j++) {
File selectedfiFile = selectedFiles[j];
SurfaceCollection surfaceCollection = ClientRequestManager.createSurfaceCollectionFromSurfaceFile(selectedfiFile);
if (surfaceCollection == null) {
throw new Exception("Expecting .stl or .mesh(salk) from file '" + selectedfiFile + "'");
}
TreeMap<Integer, ArrayList<TreeMap<Integer, TreeSet<Integer>>>> fileSurf = new TreeMap<>();
fileMapSurfMapSubsurf.put(selectedfiFile.getAbsolutePath(), fileSurf);
// nodeMapFace.add(treeMap);
TreeSet<Integer> allNodes = new TreeSet<>();
for (int k = 0; k < surfaceCollection.getNodeCount(); k++) {
allNodes.add(k);
}
TreeMap<Integer, ArrayList<TreeSet<Integer>>> allSubSurf = new TreeMap<>();
int surfOutCount = 0;
for (int i = 0; i < surfaceCollection.getSurfaceCount(); i++) {
ArrayList<TreeMap<Integer, TreeSet<Integer>>> surfMap = new ArrayList<>();
fileSurf.put(i, surfMap);
TreeMap<Integer, TreeSet<Integer>> treeMap = new TreeMap<>();
surfMap.add(treeMap);
Surface surface = surfaceCollection.getSurfaces(i);
for (int k = 0; k < surface.getPolygonCount(); k++) {
Polygon polygon = surface.getPolygons(k);
for (Node node : polygon.getNodes()) {
TreeSet<Integer> PolygonIndexes = treeMap.get(node.getGlobalIndex());
if (PolygonIndexes == null) {
PolygonIndexes = new TreeSet<Integer>();
treeMap.put(node.getGlobalIndex(), PolygonIndexes);
}
PolygonIndexes.add(k);
}
}
allSubSurf.put(i, new ArrayList<>());
while (allNodes.size() > 0) {
surfOutCount += 1;
TreeSet<Integer> searchNodes = new TreeSet<>(Arrays.asList(new Integer[] { allNodes.iterator().next() }));
TreeSet<Integer> alreadySearched = new TreeSet<>();
TreeSet<Integer> subSurf = new TreeSet<>();
allSubSurf.get(i).add(subSurf);
while (searchNodes.size() > 0) {
Integer currentNode = searchNodes.iterator().next();
searchNodes.remove(currentNode);
alreadySearched.add(currentNode);
allNodes.remove(currentNode);
TreeSet<Integer> facesForNode = treeMap.get(surfaceCollection.getNodes(currentNode).getGlobalIndex());
Iterator<Integer> facesIter = facesForNode.iterator();
while (facesIter.hasNext()) {
Integer faceIndex = facesIter.next();
subSurf.add(faceIndex);
Polygon poly = surfaceCollection.getSurfaces(i).getPolygons(faceIndex);
for (int k = 0; k < poly.getNodes().length; k++) {
if (poly.getNodes()[k].getGlobalIndex() != currentNode && !alreadySearched.contains(poly.getNodes()[k].getGlobalIndex())) {
searchNodes.add(poly.getNodes()[k].getGlobalIndex());
}
}
}
}
}
}
if (surfOutCount > surfaceCollection.getSurfaceCount()) {
SurfaceCollection newSurfCollection = new SurfaceCollection();
newSurfCollection.setNodes(surfaceCollection.getNodes());
for (Integer origSurfIndex : allSubSurf.keySet()) {
ArrayList<TreeSet<Integer>> newSubSurfaces = allSubSurf.get(origSurfIndex);
for (TreeSet<Integer> subSurf : newSubSurfaces) {
OrigSurface os = new OrigSurface(0, 1);
Iterator<Integer> polyIter = subSurf.iterator();
while (polyIter.hasNext()) {
Polygon poly = surfaceCollection.getSurfaces(origSurfIndex).getPolygons(polyIter.next());
os.addPolygon(poly);
}
newSurfCollection.addSurface(os);
}
}
allSurfCollections.add(newSurfCollection);
} else {
allSurfCollections.add(surfaceCollection);
}
// fileMapSurfMapSubsurf.get(selectedfiFile.getAbsolutePath()).get(i).add(treeMap);
}
StatsHelper statsHelper = new StatsHelper();
statsHelper.recalSurfs = allSurfCollections;
for (int j = 0; j < statsHelper.recalSurfs.size(); j++) {
// File selectedfiFile = selectedFiles[j];
// SurfaceCollection surfaceCollection = ClientRequestManager.createSurfaceCollectionFromSurfaceFile(selectedfiFile);
SurfaceCollection surfaceCollection = statsHelper.recalSurfs.get(j);
for (int i = 0; i < surfaceCollection.getNodes().length; i++) {
if (j == 0 && i == 0) {
statsHelper.xmin = surfaceCollection.getNodes()[i].getX();
statsHelper.xmax = statsHelper.xmin;
statsHelper.ymin = surfaceCollection.getNodes()[i].getY();
statsHelper.ymax = statsHelper.ymin;
statsHelper.zmin = surfaceCollection.getNodes()[i].getZ();
statsHelper.zmax = statsHelper.zmin;
}
statsHelper.xmin = Math.min(statsHelper.xmin, surfaceCollection.getNodes()[i].getX());
statsHelper.ymin = Math.min(statsHelper.ymin, surfaceCollection.getNodes()[i].getY());
statsHelper.zmin = Math.min(statsHelper.zmin, surfaceCollection.getNodes()[i].getZ());
statsHelper.xmax = Math.max(statsHelper.xmax, surfaceCollection.getNodes()[i].getX());
statsHelper.ymax = Math.max(statsHelper.ymax, surfaceCollection.getNodes()[i].getY());
statsHelper.zmax = Math.max(statsHelper.zmax, surfaceCollection.getNodes()[i].getZ());
}
}
return statsHelper;
}
use of cbit.vcell.geometry.surface.Node in project vcell by virtualcell.
the class ExportDocument method writeStanfordPolygon.
public static void writeStanfordPolygon(GeometrySurfaceDescription geometrySurfaceDescription, Writer writer) throws IOException {
int faceCount = geometrySurfaceDescription.getSurfaceCollection().getTotalPolygonCount();
int vertCount = geometrySurfaceDescription.getSurfaceCollection().getNodes().length;
writer.write("ply\n");
writer.write("format ascii 1.0\n");
writer.write("comment " + geometrySurfaceDescription.getGeometry().getName() + "\n");
writer.write("element vertex " + vertCount + "\n");
writer.write("property float x\n");
writer.write("property float y\n");
writer.write("property float z\n");
writer.write("element face " + faceCount + "\n");
writer.write("property list uchar int vertex_index\n");
writer.write("end_header\n");
// write verts x y z
for (int i = 0; i < vertCount; i++) {
Node vertex = geometrySurfaceDescription.getSurfaceCollection().getNodes()[i];
writer.write((float) vertex.getX() + " " + (float) vertex.getY() + " " + (float) vertex.getZ() + "\n");
}
// write faces as a set of connected vertex indexes
for (int i = 0; i < geometrySurfaceDescription.getSurfaceCollection().getSurfaceCount(); i++) {
for (int j = 0; j < geometrySurfaceDescription.getSurfaceCollection().getSurfaces(i).getPolygonCount(); j++) {
Quadrilateral quad = (Quadrilateral) geometrySurfaceDescription.getSurfaceCollection().getSurfaces(i).getPolygons(j);
writer.write(quad.getNodeCount() + "");
for (int k = 0; k < quad.getNodeCount(); k++) {
writer.write(" ");
writer.write(quad.getNodes(k).getGlobalIndex() + "");
}
writer.write("\n");
}
}
}
use of cbit.vcell.geometry.surface.Node in project vcell by virtualcell.
the class AVS_UCD_Exporter method writeUCDGeometryOnly.
/**
* Insert the method's description here.
* Creation date: (7/19/2004 10:54:30 AM)
* @param geometrySurfaceDescription cbit.vcell.geometry.surface.GeometrySurfaceDescription
*/
public static void writeUCDGeometryOnly(GeometrySurfaceDescription geometrySurfaceDescription, java.io.Writer writer) throws Exception {
final String QUAD_TYPE = "quad";
// GeometricRegion regions[] = geometrySurfaceDescription.getGeometricRegions();
SurfaceCollection surfaceCollection = geometrySurfaceDescription.getSurfaceCollection();
if (surfaceCollection == null) {
geometrySurfaceDescription.updateAll();
surfaceCollection = geometrySurfaceDescription.getSurfaceCollection();
}
Node[] nodes = surfaceCollection.getNodes();
int numNodes = nodes.length;
int numCells = 0;
for (int i = 0; i < surfaceCollection.getSurfaceCount(); i++) {
numCells += surfaceCollection.getSurfaces(i).getPolygonCount();
}
int numNodeData = 0;
int numCellData = 0;
int numModelData = 0;
writer.write(numNodes + " " + numCells + " " + numNodeData + " " + numCellData + " " + numModelData + "\n");
for (int i = 0; i < nodes.length; i++) {
writer.write(nodes[i].getGlobalIndex() + " " + nodes[i].getX() + " " + nodes[i].getY() + " " + nodes[i].getZ() + "\n");
}
//
// print the "Cells" (polygons) for each surface (each surface has it's own material id).
//
int cellID = 0;
for (int i = 0; i < surfaceCollection.getSurfaceCount(); i++) {
Surface surface = surfaceCollection.getSurfaces(i);
// for material now just give it the index (later need to collect these in terms of closed objects).
String materialType = Integer.toString(i);
for (int j = 0; j < surface.getPolygonCount(); j++) {
Polygon polygon = surface.getPolygons(j);
int node0Index = polygon.getNodes(0).getGlobalIndex();
int node1Index = polygon.getNodes(1).getGlobalIndex();
int node2Index = polygon.getNodes(2).getGlobalIndex();
int node3Index = polygon.getNodes(3).getGlobalIndex();
writer.write(cellID + " " + materialType + " " + QUAD_TYPE + " " + node0Index + " " + node1Index + " " + node2Index + " " + node3Index + "\n");
cellID++;
}
}
}
Aggregations