hpgl.java

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

/* -*- tab-width: 4 -*-
 *
 * Electric(tm) VLSI Design System
 *
 * File: HPGL.java
 * Input/output tool: HPGL output
 * Written by Steven M. Rubin, Sun Microsystems.
 *
 * Copyright (c) 2004 Sun Microsystems and Static Free Software
 *
 * Electric(tm) is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Electric(tm) is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Electric(tm); see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, Mass 02111-1307, USA.
 */

package com.sun.electric.tool.io.output;

import com.sun.electric.database.geometry.EGraphics;
import com.sun.electric.database.geometry.GenMath;
import com.sun.electric.database.geometry.Poly;
import com.sun.electric.database.geometry.PolyBase;
import com.sun.electric.database.geometry.PolyMerge;
import com.sun.electric.database.hierarchy.Cell;
import com.sun.electric.database.hierarchy.Export;
import com.sun.electric.database.hierarchy.HierarchyEnumerator;
import com.sun.electric.database.hierarchy.Nodable;
import com.sun.electric.database.prototype.NodeProto;
import com.sun.electric.database.text.TextUtils;
import com.sun.electric.database.topology.ArcInst;
import com.sun.electric.database.topology.NodeInst;
import com.sun.electric.database.variable.EditWindow_;
import com.sun.electric.database.variable.TextDescriptor;
import com.sun.electric.database.variable.UserInterface;
import com.sun.electric.database.variable.VarContext;
import com.sun.electric.technology.ArcProto;
import com.sun.electric.technology.Layer;
import com.sun.electric.technology.PrimitiveNode;
import com.sun.electric.technology.Technology;
import com.sun.electric.tool.Job;
import com.sun.electric.tool.user.User;

import java.awt.Color;
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

/**
 * This class writes files in HPGL/2 format.
 */
public class HPGL extends Output
{
	/** Scale to ensure that everything is integer */ private static final double SCALE = 100;

	/** conversion from Layers to pen numbers */	private HashMap<Layer,List<PolyBase>> cellGeoms;
	/** conversion from Layers to pen numbers */	private HashMap<Layer,Integer>        penNumbers;
	/** the Cell being written. */					private Cell        cell;
	/** the Window being printed (for text). */		private EditWindow_ wnd;
	/** the current line type */					private int         currentLineType;
	/** the current pen number */					private int         currentPen;
	/** if fill info written for the current pen */	private boolean     fillEmitted;

	private static class PenColor
	{
		/** line type (0=solid, 1=dotted, 2-6=dashed) */			private int lineType;
		/** fill type (0=none, 1=solid, 3=lines 4=crosshatched) */	private int fillType;
		/** fill distance between lines (fillType 3 or 4 only) */	private int fillDist;
		/** fill angle of lines (fillType 3 or 4 only) */			private int fillAngle;
	};

	private PenColor [] penColorTable;


	/**
	 * Main entry point for HPGL output.
     * @param cell the top-level cell to write.
     * @param context the hierarchical context to the cell.
	 * @param filePath the disk file to create.
	 */
	public static void writeHPGLFile(Cell cell, VarContext context, String filePath)
	{
		HPGL out = new HPGL();
		out.cell = cell;
		if (out.openTextOutputStream(filePath)) return;
		HPGLVisitor visitor = out.makeHPGLVisitor();

		// gather all geometry
		out.start();
		HierarchyEnumerator.enumerateCell(cell, context, visitor);
//		HierarchyEnumerator.enumerateCell(cell, context, null, visitor);

		// write the geometry
		out.done();

		if (out.closeTextOutputStream()) return;
		System.out.println(filePath + " written");
	}

	/** Creates a new instance of HPGL */
	private HPGL()
	{
	}

	protected void start()
	{
		cellGeoms = new HashMap<Layer,List<PolyBase>>();
		currentLineType = -1;
		currentPen = -1;
		fillEmitted = false;

		// determine the window to use for text scaling
		UserInterface ui = Job.getUserInterface();
		wnd = ui.getCurrentEditWindow_();
		if (wnd != null && wnd.getCell() != cell) wnd = null;

		// initialize pen information
		initPenData();
	}

	protected void done()
	{
		// find the area to print
		Rectangle2D printBounds = getAreaToPrint(cell, false, wnd);
		if (printBounds == null) return;

		// HPGL/2 setup and defaults
		writeLine("\033%0BBPIN");
		writeLine("LA1,4,2,4QLMC0");
		Set<Layer> layerSet = cellGeoms.keySet();
		writeLine("NP" + layerSet.size());

		// setup pens and create the mapping between Layers and HPGL pen numbers
		penNumbers = new HashMap<Layer,Integer>();
		int index = 1;
		for(Layer layer : layerSet)
		{
			penNumbers.put(layer, new Integer(index));

			Color col;
			if (layer == null) col = Color.BLACK; else
			{
				EGraphics desc = layer.getGraphics();
				if (desc.getTransparentLayer() == 0)
				{
					// opaque color: get it
					col = desc.getColor();
				} else
				{
					// transparent color: get it
					col = EGraphics.getColorFromIndex(EGraphics.makeIndex(desc.getTransparentLayer()));
				}
				if (col == null) continue;
			}
			int r = col.getRed();
			int g = col.getGreen();
			int b = col.getBlue();
			writeLine("PC" + index + "," + r + "," + g + "," + b);
			index++;
		}

		// set default location of "P1" and "P2" points on the plotter
		writeLine("IP;");
		writeLine("SC" + makeCoord(printBounds.getMinX()) + ",1," + makeCoord(printBounds.getMinY()) + ",1,2;");

		// write all geometry collected
		for(Layer layer : layerSet)
		{
			List<PolyBase> geoms = cellGeoms.get(layer);
			for (PolyBase poly : geoms)
			{
				emitPoly(poly);
			}
		}

		// HPGL/2 termination
		writeLine("PUSP0PG;");
	}

	/****************************** VISITOR SUBCLASS ******************************/

	private HPGLVisitor makeHPGLVisitor()
	{
		HPGLVisitor visitor = new HPGLVisitor(this);
		return visitor;
	}

	/**
	 * Class to override the Geometry visitor and add bloating to all polygons.
	 * Currently, no bloating is being done.
	 */
	private class HPGLVisitor extends HierarchyEnumerator.Visitor
	{
		private HPGL outGeom;

		HPGLVisitor(HPGL outGeom) { this.outGeom = outGeom; }

		/**
		 * Traverses the visible hierarchy.
		 */
		public boolean visitNodeInst(Nodable no, HierarchyEnumerator.CellInfo info)
		{
			NodeInst ni = (NodeInst)no;
			if (ni.isCellInstance())
			{
				if (!ni.isExpanded()) return false;
			}
			return true;
		}

		public boolean enterCell(HierarchyEnumerator.CellInfo info)
		{
			return true;
		}

		public void exitCell(HierarchyEnumerator.CellInfo info)
		{
			AffineTransform trans = info.getTransformToRoot();

			// prepare to merge geometry in this cell
			PolyMerge merge = new PolyMerge();

			// add nodes to cellGeom
			for(Iterator<NodeInst> it = info.getCell().getNodes(); it.hasNext();)
			{
				NodeInst ni = it.next();
				AffineTransform nodeTrans = ni.rotateOut(trans);
				if (!ni.isCellInstance())
				{
					PrimitiveNode prim = (PrimitiveNode)ni.getProto();
					Technology tech = prim.getTechnology();
					Poly[] polys = tech.getShapeOfNode(ni);
					for (int i=0; i<polys.length; i++)
						polys[i].transform(nodeTrans);
					addPolys(polys, merge);
                    Poly[] textPolys = ni.getDisplayableVariables(wnd);
					for (int i=0; i<textPolys.length; i++)
						textPolys[i].transform(nodeTrans);
					addPolys(textPolys, merge);
				} else
				{
					if (!ni.isExpanded())
					{
						Cell subCell = (Cell)ni.getProto();
						AffineTransform subTrans = ni.translateOut(nodeTrans);
						Rectangle2D bounds = subCell.getBounds();
						Poly poly = new Poly(bounds.getCenterX(), bounds.getCenterY(), ni.getXSize(), ni.getYSize());
						poly.transform(subTrans);
						poly.setStyle(Poly.Type.CLOSED);
						List<PolyBase> layerList = getListForLayer(null);
						layerList.add(poly);

						poly = new Poly(bounds.getCenterX(), bounds.getCenterY(), ni.getXSize(), ni.getYSize());
						poly.transform(subTrans);
						poly.setStyle(Poly.Type.TEXTBOX);
						TextDescriptor td = TextDescriptor.getInstanceTextDescriptor().withAbsSize(24);
						poly.setTextDescriptor(td);
						poly.setString(ni.getProto().describe(false));
						layerList.add(poly);
					}
				}

				// draw any exports from the node
				if (info.isRootCell() && User.isTextVisibilityOnExport())
				{
					int exportDisplayLevel = User.getExportDisplayLevel();
					for(Iterator<Export> eIt = ni.getExports(); eIt.hasNext(); )
					{
						Export e = eIt.next();
						Poly poly = e.getNamePoly();
						List<PolyBase> layerList = getListForLayer(null);
						if (exportDisplayLevel == 2)
						{
							// draw port as a cross
							poly.setStyle(Poly.Type.CROSS);
							layerList.add(poly);
						} else
						{
							// draw port as text
							if (exportDisplayLevel == 1)
							{
								// use shorter port name
								String portName = e.getShortName();
								poly.setString(portName);
							}
							layerList.add(poly);
						}
					}
				}
			}

			// add arcs to cellGeom
			for(Iterator<ArcInst> it = info.getCell().getArcs(); it.hasNext();)
			{
				ArcInst ai = it.next();
				ArcProto ap = ai.getProto();
				Technology tech = ap.getTechnology();
				addPolys(tech.getShapeOfArc(ai), merge);
				addPolys(ai.getDisplayableVariables(wnd), merge);
			}

			// extract merged data and add it to overall geometry
            for (Layer layer : merge.getKeySet())
			{
				List<PolyBase> layerList = getListForLayer(layer);
				List<PolyBase> geom = merge.getMergedPoints(layer, true);
				for(PolyBase poly : geom)
					layerList.add(poly);
			}
		}

		/** add polys to cell geometry */
		private void addPolys(Poly[] polys, PolyMerge merge)
		{
			for (int i=0; i<polys.length; i++)
			{
				Poly poly = polys[i];
				Layer layer = poly.getLayer();
				if (layer == null || poly.getStyle() != Poly.Type.FILLED)
				{
					List<PolyBase> layerList = getListForLayer(layer);
					layerList.add(poly);
					continue;
				}

				merge.addPolygon(layer, poly);
			}
		}

		private List<PolyBase> getListForLayer(Layer layer)
		{
			List<PolyBase> layerList = outGeom.cellGeoms.get(layer);