dxf.java

The ElectricTM VLSI Design System is an open-source Electronic Design Automation (EDA) system that c

								break;
							case 4:			    // cyan
								layer.layerRed = 0.0;    layer.layerGreen = 1.0;    layer.layerBlue = 1.0;
								break;
							case 5:			    // blue
								layer.layerRed = 0.0;    layer.layerGreen = 0.0;    layer.layerBlue = 1.0;
								break;
							case 6:			    // magenta
								layer.layerRed = 1.0;    layer.layerGreen = 0.0;    layer.layerBlue = 1.0;
								break;
							case 7:			    // white (well, gray)
								layer.layerRed = 0.75;    layer.layerGreen = 0.75;    layer.layerBlue = 0.75;
								break;
							default:			// unknown layer
								layer.layerRed = Math.random();
								layer.layerGreen = Math.random();
								layer.layerBlue = Math.random();
								break;
						}
					}
				}
			}
		}
		return false;
	}

	private boolean ignoreSection()
		throws IOException
	{
		// just ignore everything until the end-of-section
		for(;;)
		{
			if (getNextPair()) return true;
			if (groupID == 0 && text.equals("ENDSEC")) break;
		}
		return false;
	}

	/****************************************** READING ENTITIES ******************************************/

	private boolean readEntities(Library lib)
		throws IOException
	{
		// read the blocks/entities section
		for(;;)
		{
			if (getNextPair()) return true;
			if (groupID != 0)
			{
				System.out.println("Unknown group code (" + groupID + ") at line " + lineReader.getLineNumber());
				return true;
			}
			if (text.equals("ARC"))
			{
				if (readArcEntity()) return true;
				continue;
			}
			if (text.equals("ATTDEF"))
			{
				ignoreEntity();
				ignoredAttributeDefs++;
				continue;
			}
			if (text.equals("ATTRIB"))
			{
				ignoreEntity();
				ignoredAttributes++;
				continue;
			}
			if (text.equals("BLOCK"))
			{
				String msg = readBlock();
				if (msg == null) return true;
				curCell = Cell.makeInstance(lib, makeBlockName(msg));
				if (curCell == null) return true;
				continue;
			}
			if (text.equals("CIRCLE"))
			{
				if (readCircleEntity()) return true;
				continue;
			}
			if (text.equals("ENDBLK"))
			{
				ignoreEntity();
				curCell = mainCell;
				continue;
			}
			if (text.equals("ENDSEC"))
			{
				break;
			}
			if (text.equals("INSERT"))
			{
				if (readInsertEntity(lib)) return true;
				continue;
			}
			if (text.equals("LINE"))
			{
				if (readLineEntity()) return true;
				continue;
			}
			if (text.equals("POINT"))
			{
				ignoreEntity();
				ignoredPoints++;
				continue;
			}
			if (text.equals("POLYLINE"))
			{
				if (readPolyLineEntity()) return true;
				continue;
			}
			if (text.equals("SEQEND"))
			{
				ignoreEntity();
				continue;
			}
			if (text.equals("SOLID"))
			{
				if (readSolidEntity()) return true;
				continue;
			}
			if (text.equals("TEXT"))
			{
				if (readTextEntity()) return true;
				continue;
			}
			if (text.equals("VIEWPORT"))
			{
				ignoreEntity();
				continue;
			}
			if (text.equals("3DFACE"))
			{
				if (read3DFaceEntity()) return true;
				continue;
			}
			System.out.println("Unknown entity type (" + text + ") at line " + lineReader.getLineNumber());
			return true;
		}
		return false;
	}

	private double scaleString(String text)
	{
		double v = TextUtils.atof(text);
		return TextUtils.convertFromDistance(v,Artwork.tech(), dispUnit);
	}

	private boolean readArcEntity()
		throws IOException
	{
		DXFLayer layer = null;
		double x = 0, y = 0;
		double rad = 0;
		double sAngle = 0, eAngle = 0;
		for(;;)
		{
			if (getNextPair()) return true;
			switch (groupID)
			{
				case 8:  layer = getLayer(text);          break;
				case 10: x = scaleString(text);           break;
				case 20: y = scaleString(text);           break;
				case 30: /* ignore Z */                   break;
				case 40: rad = scaleString(text);         break;
				case 50: sAngle = TextUtils.atof(text);   break;
				case 51: eAngle = TextUtils.atof(text);   break;
			}
			if (groupID == 0)
			{
				pushPair(groupID, text);
				break;
			}
		}
		if (!isAcceptableLayer(layer)) return false;
		if (sAngle >= 360.0) sAngle -= 360.0;
		int iAngle = (int)(sAngle * 10.0);
		Orientation orient = Orientation.fromAngle(iAngle);
		NodeInst ni = NodeInst.makeInstance(Artwork.tech().circleNode, new Point2D.Double(x, y), rad*2, rad*2, curCell, orient, null, 0);
		if (ni == null) return true;
		if (sAngle > eAngle) eAngle += 360.0;
		double startOffset = sAngle;
		startOffset -= iAngle / 10.0;
		ni.setArcDegrees(startOffset * Math.PI / 1800.0, (eAngle-sAngle) * Math.PI / 180.0);
		ni.newVar(DXF_LAYER_KEY, layer.layerName);
		readArcs++;
		return false;
	}

	private String readBlock()
		throws IOException
	{
		String saveMsg = null;
		for(;;)
		{
			if (getNextPair()) return null;
			if (groupID == 2) saveMsg = text; else
			if (groupID == 0)
			{
				pushPair(groupID, text);
				break;
			}
		}
		return saveMsg;
	}

	private boolean readCircleEntity()
		throws IOException
	{
		DXFLayer layer = null;
		double x = 0, y = 0;
		double rad = 0;
		for(;;)
		{
			if (getNextPair()) return true;
			switch (groupID)
			{
				case 8:  layer = getLayer(text);    break;
				case 10: x = scaleString(text);     break;
				case 20: y = scaleString(text);     break;
				case 30: /* ignore Z */             break;
				case 40: rad = scaleString(text);   break;
			}
			if (groupID == 0)
			{
				pushPair(groupID, text);
				break;
			}
		}
		if (!isAcceptableLayer(layer)) return false;
		NodeInst ni = NodeInst.makeInstance(Artwork.tech().circleNode, new Point2D.Double(x, y), rad*2, rad*2, curCell);
		if (ni == null) return true;
		ni.newVar(DXF_LAYER_KEY, layer.layerName);
		readCircles++;
		return false;
	}

	private boolean readInsertEntity(Library lib)
		throws IOException
	{
		int rot = 0;
		String name = null;
		int xRep = 1, yRep = 1;
		double x = 0, y = 0;
		double xSca = 1, ySca = 1;
		for(;;)
		{
			if (getNextPair()) return true;
			switch (groupID)
			{
				case 8:  /* ignore layer */               break;
				case 10: x = scaleString(text);           break;
				case 20: y = scaleString(text);           break;
				case 30: /* ignore Z */                   break;
				case 50: rot = TextUtils.atoi(text);      break;
				case 41: xSca = TextUtils.atof(text);     break;
				case 42: ySca = TextUtils.atof(text);     break;
				case 70: xRep = TextUtils.atoi(text);     break;
				case 71: yRep = TextUtils.atoi(text);     break;
				case 44: /* ignore X spacing */           break;
				case 45: /* ignore Y spacing */           break;
				case 2:  name = text;                     break;
			}
			if (groupID == 0)
			{
				pushPair(groupID, text);
				break;
			}
		}

		String pt = makeBlockName(name);
		if (pt != null)
		{
			if (xRep != 1 || yRep != 1)
			{
				System.out.println("Cannot insert block '" + pt + "' repeated " + xRep + "x" + yRep + " times");
				return false;
			}

			// have to search by hand because of weird prototype names
			Cell found = null;
			for(Iterator<Cell> it = lib.getCells(); it.hasNext(); )
			{
				Cell np = it.next();
				if (np.getName().equals(pt)) { found = np;   break; }
			}
			if (found == null)
			{
				ForwardRef fr = new ForwardRef();
				fr.refName = pt;
				fr.parent = curCell;
				fr.x = x;		fr.y = y;
				fr.rot = rot;
				fr.xSca = xSca;	fr.ySca = ySca;
				fr.nextForwardRef = firstForwardRef;
				firstForwardRef = fr;
				return false;
			}

			if (IOTool.isDXFInputFlattensHierarchy())
			{
				if (extractInsert(found, x, y, xSca, ySca, rot, curCell)) return true;
			} else
			{
				if (xSca != 1.0 || ySca != 1.0)
				{
					found = getScaledCell(found, xSca, ySca);
					if (found == null) return true;
				}
				double sX = found.getDefWidth();
				double sY = found.getDefHeight();
                Orientation orient = Orientation.fromAngle(rot*10);
				NodeInst ni = NodeInst.makeInstance(found, new Point2D.Double(x, y), sX, sY, curCell, orient, null, 0);
				if (ni == null) return true;
				ni.setExpanded();
			}
		}
		readInserts++;
		return false;
	}

	private boolean readLineEntity()
		throws IOException
	{
		DXFLayer layer = null;
		int lineType = 0;
		double x1 = 0, y1 = 0;
		double x2 = 0, y2 = 0;
		for(;;)
		{
			if (getNextPair()) return true;
			switch (groupID)
			{
				case 8:  layer = getLayer(text);     break;
				case 10: x1 = scaleString(text);     break;
				case 20: y1 = scaleString(text);     break;
				case 30: /* ignore Z */              break;
				case 11: x2 = scaleString(text);     break;
				case 21: y2 = scaleString(text);     break;
				case 31: /* ignore Z */              break;
			}
			if (groupID == 0)
			{
				pushPair(groupID, text);
				break;
			}
		}
		if (!isAcceptableLayer(layer)) return false;
		double cX = (x1 + x2) / 2;
		double cY = (y1 + y2) / 2;
		double sX = Math.abs(x1 - x2);
		double sY = Math.abs(y1 - y2);
		NodeProto np = Artwork.tech().openedDashedPolygonNode;
		if (lineType == 0) np = Artwork.tech().openedPolygonNode;
		NodeInst ni = NodeInst.makeInstance(np, new Point2D.Double(cX, cY), sX, sY, curCell);
		if (ni == null) return true;
		EPoint [] points = new EPoint[2];
		points[0] = new EPoint(x1, y1);
		points[1] = new EPoint(x2, y2);
		ni.setTrace(points);
		ni.newVar(DXF_LAYER_KEY, layer.layerName);
		readLines++;
		return false;
	}

	private boolean readPolyLineEntity()
		throws IOException
	{
		boolean closed = false;
		DXFLayer layer = null;
		int lineType = 0;
		boolean inEnd = false;
		List<PolyPoint> polyPoints = new ArrayList<PolyPoint>();
		PolyPoint curPP = null;
		boolean hasBulgeInfo = false;
		for(;;)
		{
			if (getNextPair()) return true;
			if (groupID == 8)
			{
				layer = getLayer(text);
				continue;
			}

			if (groupID == 10)
			{
				if (curPP != null) curPP.x = scaleString(text);
				continue;
			}
			if (groupID == 20)
			{
				if (curPP != null) curPP.y = scaleString(text);
				continue;
			}
			if (groupID == 30)
			{
				if (curPP != null) curPP.z = scaleString(text);
				continue;
			}
			if (groupID == 42)
			{
				if (curPP != null)
				{
					curPP.bulge = TextUtils.atof(text);
					if (curPP.bulge != 0) hasBulgeInfo = true;
				}
				continue;
			}
			if (groupID == 70)
			{
				int i = TextUtils.atoi(text);
				if ((i&1) != 0) closed = true;
				continue;
			}

			if (groupID == 0)
			{
				if (inEnd)
				{
					pushPair(groupID, text);
					break;
				}
				if (text.equals("SEQEND"))
				{
					inEnd = true;
					continue;
				}
				if (text.equals("VERTEX"))
				{
					curPP = new PolyPoint();
					curPP.bulge = 0;
					polyPoints.add(curPP);
				}
				continue;
			}
		}

		int count = polyPoints.size();
		if (isAcceptableLayer(layer) && count >= 3)
		{
			// see if there is bulge information
			if (hasBulgeInfo)
			{
				// handle bulges
				int start = 1;
				if (closed) start = 0;
				for(int i=start; i<count; i++)
				{
					int last = i - 1;
					if (i == 0) last = count-1;
					PolyPoint pp = polyPoints.get(i);
					PolyPoint lastPp = polyPoints.get(last);
					double x1 = lastPp.x;   double y1 = lastPp.y;
					double x2 = pp.x;       double y2 = pp.y;
					if (lastPp.bulge != 0.0)
					{
						// special case the semicircle bulges
						if (Math.abs(lastPp.bulge) == 1.0)
						{
							double cX = (x1 + x2) / 2;
							double cY = (y1 + y2) / 2;
							if ((y1 == cY && x1 == cX) || (y2 == cY && x2 == cX))
							{
								System.out.println("Domain error in polyline bulge computation");
								continue;
							}
							double sA = Math.atan2(y1-cY, x1-cX);
							double eA = Math.atan2(y2-cY, x2-cX);
							if (lastPp.bulge < 0.0)
							{
								double r2 = sA;   sA = eA;   eA = r2;
							}
							if (sA < 0.0) sA += 2.0 * Math.PI;
							sA = sA * 1800.0 / Math.PI;
							int iAngle = (int)sA;
							double rad = new Point2D.Double(cX, cY).distance(new Point2D.Double(x1, y1));
                            Orientation orient = Orientation.fromAngle(iAngle);
							NodeInst ni = NodeInst.makeInstance(Artwork.tech().circleNode, new Point2D.Double(cX, cY), rad*2, rad*2, curCell, orient, null, 0);
							if (ni == null) return true;
							double startOffset = sA;
							startOffset -= iAngle;
							ni.setArcDegrees(startOffset * Math.PI / 1800.0, Math.PI);
							ni.newVar(DXF_LAYER_KEY, layer.layerName);
							continue;
						}

						// compute half distance between the points
						double x01 = x1;   double y01 = y1;
						double x02 = x2;   double y02 = y2;
						double dx = x02 - x01;   double dy = y02 - y01;
						double dist = Math.hypot(dx, dy);

						// compute radius of arc (bulge is tangent of 1/4 of included arc angle)
						double incAngle = Math.atan(lastPp.bulge) * 4.0;
						double arcRad = Math.abs((dist / 2.0) / Math.sin(incAngle / 2.0));
						double rad = arcRad;

						// prepare to compute the two circle centers
						double r2 = arcRad*arcRad;
						double delta_1 = -dist / 2.0;
						double delta_12 = delta_1 * delta_1;
						double delta_2 = Math.sqrt(r2 - delta_12);

						// pick one center, according to bulge sign
						double bulgeSign = lastPp.bulge;
						if (Math.abs(bulgeSign) > 1.0) bulgeSign = -bulgeSign;
						double xcf = 0, ycf = 0;
						if (bulgeSign > 0.0)
						{
							xcf = x02 + ((delta_1 * (x02-x01)) + (delta_2 * (y01-y02))) / dist;
							ycf = y02 + ((delta_1 * (y02-y01)) + (delta_2 * (x02-x01))) / dist;
						} else
						{
							xcf = x02 + ((delta_1 * (x02-x01)) + (delta_2 * (y02-y01))) / dist;
							ycf = y02 + ((delta_1 * (y02-y01)) + (delta_2 * (x01-x02))) / dist;