dxf.java

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

						}
						x1 = xcf;   y1 = ycf;

						// compute angles to the arc endpoints
						if ((y01 == ycf && x01 == xcf) || (y02 == ycf && x02 == xcf))
						{
							System.out.println("Domain error in polyline computation");
							continue;
						}
						double sA = Math.atan2(y01-ycf, x01-xcf);
						double eA = Math.atan2(y02-ycf, x02-xcf);
						if (lastPp.bulge < 0.0)
						{
							r2 = sA;   sA = eA;   eA = r2;
						}
						if (sA < 0.0) sA += 2.0 * Math.PI;
						if (eA < 0.0) eA += 2.0 * Math.PI;
						sA = sA * 1800.0 / Math.PI;
						eA = eA * 1800.0 / Math.PI;

						// create the arc node
						int iAngle = (int)sA;
                        Orientation orient = Orientation.fromAngle(iAngle);
						NodeInst ni = NodeInst.makeInstance(Artwork.tech().circleNode, new Point2D.Double(x1, y1), rad*2, rad*2, curCell, orient, null, 0);
						if (ni == null) return true;
						if (sA > eA) eA += 3600.0;
						double startOffset = sA;
						startOffset -= iAngle;
						ni.setArcDegrees(startOffset * Math.PI / 1800.0, (eA-sA) * Math.PI / 1800.0);
						ni.newVar(DXF_LAYER_KEY, layer.layerName);
						continue;
					}

					// this segment has no bulge
					double cX = (x1 + x2) / 2;
					double cY = (y1 + y2) / 2;
					NodeProto np = Artwork.tech().openedDashedPolygonNode;
					if (lineType == 0) np = Artwork.tech().openedPolygonNode;
					NodeInst ni = NodeInst.makeInstance(np, new Point2D.Double(cX, cY), Math.abs(x1 - x2), Math.abs(y1 - y2), curCell);
					if (ni == null) return true;
					Point2D [] points = new Point2D[2];
					points[0] = new Point2D.Double(x1, y1);
					points[1] = new Point2D.Double(x2, y2);
					ni.setTrace(points);
					ni.newVar(DXF_LAYER_KEY, layer.layerName);
				}
			} else
			{
				// no bulges: do simple polygon
				double lX = 0, hX = 0;
				double lY = 0, hY = 0;
				for(int i=0; i<count; i++)
				{
					PolyPoint pp = polyPoints.get(i);
					if (i == 0)
					{
						lX = hX = pp.x;
						lY = hY = pp.y;
					} else
					{
						if (pp.x < lX) lX = pp.x;
						if (pp.x > hX) hX = pp.x;
						if (pp.y < lY) lY = pp.y;
						if (pp.y > hY) hY = pp.y;
					}
				}
				double cX = (lX + hX) / 2;
				double cY = (lY + hY) / 2;
				NodeProto np = Artwork.tech().closedPolygonNode;
				if (!closed)
				{
					if (lineType == 0) np = Artwork.tech().openedPolygonNode; else
						np = Artwork.tech().openedDashedPolygonNode;
				}
				NodeInst ni = NodeInst.makeInstance(np, new Point2D.Double(cX, cY), hX-lX, hY-lY, curCell);
				if (ni == null) return true;
				Point2D [] points = new Point2D[count];
				for(int i=0; i<count; i++)
				{
					PolyPoint pp = polyPoints.get(i);
					points[i] = new Point2D.Double(pp.x, pp.y);
				}
				ni.setTrace(points);
				ni.newVar(DXF_LAYER_KEY, layer.layerName);
			}
		}
		readPolyLines++;
		return false;
	}

	private boolean readSolidEntity()
		throws IOException
	{
		DXFLayer layer = null;
		double factor = 1.0;
		double x1 = 0, y1 = 0;
		double x2 = 0, y2 = 0;
		double x3 = 0, y3 = 0;
		double x4 = 0, y4 = 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;
				case 12: x3 = scaleString(text);     break;
				case 22: y3 = scaleString(text);     break;
				case 32: /* ignore Z */              break;
				case 13: x4 = scaleString(text);     break;
				case 23: y4 = scaleString(text);     break;
				case 33: /* ignore Z */              break;
				case 230:
					factor = TextUtils.atof(text);
					break;
			}
			if (groupID == 0)
			{
				pushPair(groupID, text);
				break;
			}
		}
		x1 = x1 * factor;
		x2 = x2 * factor;
		x3 = x3 * factor;
		x4 = x4 * factor;
		if (!isAcceptableLayer(layer)) return false;
		double lX = Math.min(Math.min(x1, x2), Math.min(x3, x4));
		double hX = Math.max(Math.max(x1, x2), Math.max(x3, x4));
		double lY = Math.min(Math.min(y1, y2), Math.min(y3, y4));
		double hY = Math.max(Math.max(y1, y2), Math.max(y3, y4));
		double cX = (lX + hX) / 2;
		double cY = (lY + hY) / 2;
		NodeInst ni = NodeInst.makeInstance(Artwork.tech().filledPolygonNode, new Point2D.Double(cX, cY), hX-lX, hY-lY, curCell);
		if (ni == null) return true;
		Point2D [] points = new Point2D[4];
		points[0] = new Point2D.Double(x1, y1);
		points[1] = new Point2D.Double(x2, y2);
		points[2] = new Point2D.Double(x3, y3);
		points[3] = new Point2D.Double(x4, y4);
		ni.setTrace(points);
		ni.newVar(DXF_LAYER_KEY, layer.layerName);
		readSolids++;
		return false;
	}

	private boolean readTextEntity()
		throws IOException
	{
		DXFLayer layer = null;
		String msg = null;
		double x = 0, y = 0;
		double height = 0, xAlign = 0;
		boolean gotXA = false;
		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 40: height = scaleString(text);                   break;
				case 11: xAlign = scaleString(text);   gotXA = true;   break;
				case 1:  msg = text;                                   break;
			}
			if (groupID == 0)
			{
				pushPair(groupID, text);
				break;
			}
		}
		double lX = x, hX = x;
		double lY = y, hY = y;
		if (gotXA)
		{
			lX = Math.min(x, xAlign);
			hX = lX + Math.abs(xAlign-x) * 2;
			lY = y;
			hY = y + height;
		} else
		{
			if (msg != null)
			{
				double h = msg.length();
				lX = x;	hX = x + height * h;
				lY = y;	hY = y + height;
			}
		}
		if (!isAcceptableLayer(layer)) return false;
		if (msg != null)
		{
			NodeInst ni = NodeInst.makeInstance(Generic.tech().invisiblePinNode, new Point2D.Double((lX+hX)/2, (lY+hY)/2), hX-lX, hY-lY, curCell);
			if (ni == null) return true;
            TextDescriptor td = TextDescriptor.getNodeTextDescriptor().withPos(TextDescriptor.Position.BOXED).withAbsSize(TextDescriptor.Size.TXTMAXPOINTS);
            ni.newVar(Artwork.ART_MESSAGE, msg, td);
			ni.newVar(DXF_LAYER_KEY, layer.layerName);
			readTexts++;
		}
		return false;
	}

	private boolean read3DFaceEntity()
		throws IOException
	{
		DXFLayer layer = null;
		double x1 = 0, y1 = 0;
		double x2 = 0, y2 = 0;
		double x3 = 0, y3 = 0;
		double x4 = 0, y4 = 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;

				case 12: x3 = scaleString(text);   break;
				case 22: y3 = scaleString(text);   break;
				case 32: /* ignore Z */            break;

				case 13: x4 = scaleString(text);   break;
				case 23: y4 = scaleString(text);   break;
				case 33: /* ignore Z */            break;
			}
			if (groupID == 0)
			{
				pushPair(groupID, text);
				break;
			}
		}
		if (!isAcceptableLayer(layer)) return false;
		double lX = Math.min(Math.min(x1, x2), Math.min(x3, x4));
		double hX = Math.max(Math.max(x1, x2), Math.max(x3, x4));
		double lY = Math.min(Math.min(y1, y2), Math.min(y3, y4));
		double hY = Math.max(Math.max(y1, y2), Math.max(y3, y4));
		double cX = (lX + hX) / 2;
		double cY = (lY + hY) / 2;
		NodeInst ni = NodeInst.makeInstance(Artwork.tech().closedPolygonNode, new Point2D.Double(cX, cY), hX-lX, hY-lY, curCell);
		if (ni == null) return true;
		Point2D [] points = new Point2D[4];
		points[0] = new Point2D.Double(x1, y1);
		points[1] = new Point2D.Double(x2, y2);
		points[2] = new Point2D.Double(x3, y3);
		points[3] = new Point2D.Double(x4, y4);
		ni.setTrace(points);
		ni.newVar(DXF_LAYER_KEY, layer.layerName);
		read3DFaces++;
		return false;
	}

	private void ignoreEntity()
		throws IOException
	{
		for(;;)
		{
			if (getNextPair()) break;
			if (groupID == 0) break;
		}
		pushPair(groupID, text);
	}

	/****************************************** READING SUPPORT ******************************************/

	private boolean isAcceptableLayer(DXFLayer layer)
	{
		if (layer == null) return false;
		if (IOTool.isDXFInputReadsAllLayers()) return true;
		if (validLayerNames.contains(layer.layerName)) return true;

		// add this to the list of layer names that were ignored
		ignoredLayerNames.add(layer.layerName);
		return false;
	}

	private boolean extractInsert(Cell onp, double x, double y, double xSca, double ySca, int rot, Cell np)
	{
		// rotate "rot*10" about point [(onp->lowx+onp->highx)/2+x, (onp->lowy+onp->highy)/2+y]
        Orientation orient = Orientation.fromAngle(rot*10);
        AffineTransform trans = orient.pureRotate();
		double m00 = trans.getScaleX();
		double m01 = trans.getShearX();
		double m11 = trans.getScaleY();
		double m10 = trans.getShearY();
		Rectangle2D bounds = onp.getBounds();
		double m02 = bounds.getCenterX() + x;
		double m12 = bounds.getCenterY() + y;
		trans.setTransform(m00, m10, m01, m11, m02, m12);
		Point2D pt = new Point2D.Double(-m02, -m12);
		trans.transform(pt, pt);
		trans.setTransform(m00, m10, m01, m11, pt.getX(), pt.getY());

		for(Iterator<NodeInst> it = onp.getNodes(); it.hasNext(); )
		{
			NodeInst ni = it.next();
			if (ni.isCellInstance())
			{
				System.out.println("Cannot insert block '" + onp + "'...it has inserts in it");
				return true;
			}
			if (ni.getProto() == Generic.tech().cellCenterNode) continue;
			double sX = ni.getXSize() * xSca;
			double sY = ni.getYSize() * ySca;
			double cX = x + ni.getAnchorCenterX() * xSca;
			double cY = y + ni.getAnchorCenterY() * ySca;
			Point2D tPt = new Point2D.Double(cX, cY);
			trans.transform(tPt, tPt);
			NodeInst nNi = NodeInst.makeInstance(ni.getProto(), tPt, sX, sY, np, orient.concatenate(ni.getOrient()), null, 0);
			if (nNi == null) return true;
			if (ni.getProto() == Artwork.tech().closedPolygonNode || ni.getProto() == Artwork.tech().filledPolygonNode ||
				ni.getProto() == Artwork.tech().openedPolygonNode || ni.getProto() == Artwork.tech().openedDashedPolygonNode)
			{
				// copy trace information
				Point2D [] oldTrace = ni.getTrace();
				if (oldTrace != null)
				{
					int len = oldTrace.length;
					Point2D [] newTrace = new Point2D[len];
					for(int i=0; i<len; i++)
					{
						if (oldTrace[i] != null)
							newTrace[i] = new Point2D.Double(cX + oldTrace[i].getX() * xSca, cY + oldTrace[i].getY() * ySca);
					}
					nNi.setTrace(newTrace);
				}
			} else if (ni.getProto() == Generic.tech().invisiblePinNode)
			{
				// copy text information
				Variable var = ni.getVar(Artwork.ART_MESSAGE);
				if (var != null)
				{
					nNi.newVar(Artwork.ART_MESSAGE, var.getObject(), var.getTextDescriptor());
				}
			} else if (ni.getProto() == Artwork.tech().circleNode || ni.getProto() == Artwork.tech().thickCircleNode)
			{
				// copy arc information
				double [] curvature = ni.getArcDegrees();
				nNi.setArcDegrees(curvature[0], curvature[1]);
			}

			// copy other information
			Variable var = ni.getVar(DXF_LAYER_KEY);
			if (var != null) nNi.newVar(DXF_LAYER_KEY, var.getObject());
			var = ni.getVar(Artwork.ART_COLOR);
			if (var != null) nNi.newVar(Artwork.ART_COLOR, var.getObject());
		}
		return false;
	}

	private Cell getScaledCell(Cell onp, double xSca, double ySca)
	{
		String fViewName = "scaled" + xSca + "x" + ySca;
		String sViewName = "s" + xSca + "x" + ySca;
		View view = View.findView(fViewName);
		if (view == null)
		{
			view = View.newInstance(fViewName, sViewName);
			if (view == null) return null;
		}

		// find the view of this cell
		Cell rightView = onp.otherView(view);
		if (rightView != null) return rightView;

		// not found: create it
		String cellName = onp.getName() + "{" + sViewName + "}";
		Cell np = Cell.makeInstance(onp.getLibrary(), cellName);
		if (np == null) return null;

		for(Iterator<NodeInst> it = onp.getNodes(); it.hasNext(); )
		{
			NodeInst ni = it.next();
			if (ni.isCellInstance())
			{
				System.out.println("Cannot insert block '" + onp + "'...it has inserts in it");
				return null;
			}
			NodeInst nNi = NodeInst.makeInstance(ni.getProto(), ni.getAnchorCenter(),
				ni.getXSize()*xSca, ni.getYSize()*ySca, np, ni.getOrient(), null, 0);
			if (nNi == null) return null;
			if (ni.getProto() == Artwork.tech().closedPolygonNode || ni.getProto() == Artwork.tech().filledPolygonNode ||
				ni.getProto() == Artwork.tech().openedPolygonNode || ni.getProto() == Artwork.tech().openedDashedPolygonNode)
			{
				// copy trace information
				Point2D [] oldTrace = ni.getTrace();
				if (oldTrace != null)
				{
					int len = oldTrace.length;
					Point2D [] newTrace = new Point2D[len];
					for(int i=0; i<len; i++)
					{
						if (oldTrace[i] != null)
							newTrace[i] = new Point2D.Double(oldTrace[i].getX() * xSca, oldTrace[i].getY() * ySca);
					}
					nNi.setTrace(newTrace);
				}
			} else if (ni.getProto() == Generic.tech().invisiblePinNode)
			{
				// copy text information
				Variable var = ni.getVar(Artwork.ART_MESSAGE);
				if (var != null)
				{
					nNi.newVar(Artwork.ART_MESSAGE, var.getObject(), var.getTextDescriptor());
				}
			} else if (ni.getProto() == Artwork.tech().circleNode || ni.getProto() == Artwork.tech().thickCircleNode)
			{
				// copy arc information
				double [] curvature = ni.getArcDegrees();
				nNi.setArcDegrees(curvature[0], curvature[1]);
			}

			// copy layer information
			Variable var = ni.getVar(DXF_LAYER_KEY);
			if (var != null) nNi.newVar(DXF_LAYER_KEY, var.getObject());
		}
		return np;
	}

	private DXFLayer getLayer(String name)
	{
		for(DXFLayer layer = firstLayer; layer != null; layer = layer.next)
			if (name.equals(layer.layerName)) return layer;

		// create a new one
		DXFLayer layer = new DXFLayer();
		layer.layerName = name;
		layer.layerColor = -1;
		layer.layerRed = 1.0;
		layer.layerGreen = 1.0;
		layer.layerBlue = 1.0;
		layer.next = firstLayer;
		firstLayer = layer;
		return layer;
	}

	private void pushPair(int groupID, String text)
	{
		lastGroupID = groupID;
		lastText = text;
		lastPairValid = true;
	}

	/**
	 * Method to examine the layer names on the artwork technology and obtain
	 * a list of acceptable layer names and numbers.
	 */
	private void getAcceptableLayers()
	{
		validLayerNames = new HashSet<String>();
		for(Iterator<Layer> it = Artwork.tech().getLayers(); it.hasNext(); )
		{
			Layer lay = it.next();
			String layNames = lay.getDXFLayer();
			if (layNames == null) continue;
			while (layNames.length() > 0)
			{
				int commaPos = layNames.indexOf(',');
				if (commaPos < 0) commaPos = layNames.length();
				String oneName = layNames.substring(0, commaPos);
				validLayerNames.add(oneName);
				layNames = layNames.substring(oneName.length());
				if (layNames.startsWith(",")) layNames = layNames.substring(1);
			}
		}
	}

	/**
	 * Method to convert a block name "name" into a valid Electric cell name (converts
	 * bad characters).
	 */
	private String makeBlockName(String name)
	{
		StringBuffer infstr = new StringBuffer();
		for(int i=0; i<name.length(); i++)
		{
			char chr = name.charAt(i);
			if (chr == '$' || chr == '{' || chr == '}' || chr == ':') chr = '_';
			infstr.append(chr);
		}
		return infstr.toString();
	}

	/**
	 * Method to set the conversion units between DXF files and real distance.
	 * The value is stored in the global "dispUnit".
	 */
	private void setCurUnits()
	{
		int units = IOTool.getDXFScale();
		switch (units)
		{
			case -3: dispUnit = TextUtils.UnitScale.GIGA;   break;
			case -2: dispUnit = TextUtils.UnitScale.MEGA;   break;
			case -1: dispUnit = TextUtils.UnitScale.KILO;   break;
			case  0: dispUnit = TextUtils.UnitScale.NONE;   break;
			case  1: dispUnit = TextUtils.UnitScale.MILLI;  break;
			case  2: dispUnit = TextUtils.UnitScale.MICRO;  break;
			case  3: dispUnit = TextUtils.UnitScale.NANO;   break;
			case  4: dispUnit = TextUtils.UnitScale.PICO;   break;
			case  5: dispUnit = TextUtils.UnitScale.FEMTO;  break;
		}
	}
}